From: PASCALE NOYRET
Date: Mon, 11 Dec 2023 15:01:51 +0000 (+0100)
Subject: premiers chgts de directory
X-Git-Tag: avantLeRenommagePourEric~6
X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=50dbfb4ea5b9d4c162942330965ccf1d26ad49b0;p=tools%2Feficas.git
premiers chgts de directory
---
diff --git a/Editeur/comploader.py b/Editeur/comploader.py
index 414fda56..7c9e7941 100644
--- a/Editeur/comploader.py
+++ b/Editeur/comploader.py
@@ -45,7 +45,7 @@ def chargerComposants(GUIPath):
et de remplir le dictionnaire composants utilise par makeObjecttreeitem
"""
debug = 0
- repertoire = os.path.join("..", GUIPath)
+ repertoire = os.path.join("..", "Interface",GUIPath)
package = GUIPath
listfich = glob.glob(os.path.join(repertoire, "compo*.py"))
for fichier in listfich:
diff --git a/Editeur/eficas_go.py b/Editeur/eficas_go.py
new file mode 100755
index 00000000..3498d2a7
--- /dev/null
+++ b/Editeur/eficas_go.py
@@ -0,0 +1,420 @@
+#!/usr/bin/env python
+# -*- 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
+# 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
+#
+
+# Modules Python
+
+import sys, os
+
+repIni = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), ".."))
+
+if sys.version_info[0] < 3:
+ print("Must be using Python 3")
+ sys.exit()
+
+
+def lanceEficas(code=None, multi=False, langue="en", labelCode=None, GUI='QT5', salome=0):
+# ---------------------------------------------------------------------------------------
+ """
+ Lance l'appli EFICAS avec Ihm QT
+ """
+ try:
+ from PyQt5.QtWidgets import QApplication
+ except:
+ print("Please, set qt environment")
+ return
+
+ from Editeur import session
+
+ options = session.parse(sys.argv)
+ if options.code != None:
+ code = options.code
+
+ pathGui='InterfaceGUI.QT5.qtEficas'
+ qtEficas =__import__(pathGui, globals(), locals(), ['qtEficas',])
+
+ app = QApplication(sys.argv)
+ Eficas = qtEficas.Appli(code=code, salome=salome, multi=multi, langue=langue, labelCode=labelCode, GUI=GUI)
+ Eficas.show()
+
+ res = app.exec_()
+ sys.exit(res)
+
+
+def getEficasSsIhm( code=None, multi=False, langue="en", ssCode=None, labelCode=None,
+ forceXML=False, genereXSD=False, fichierCata=None,):
+# -----------------------------------------------------------------------------------
+ """
+ instancie l'appli EFICAS sans Ihm
+ """
+ from Editeur import session
+
+ options = session.parse(sys.argv)
+ if options.code != None:
+ code = options.code
+ if forceXML:
+ options.withXSD = True
+
+ from InterfaceQT4.qtEficasSsIhm import AppliSsIhm
+
+ Eficas = AppliSsIhm( code=code, salome=0, multi=multi, langue=langue,
+ ssCode=ssCode, labelCode=labelCode, genereXSD=genereXSD, fichierCata=fichierCata,)
+ return Eficas
+
+
+def genereXSD(code=None):
+# -----------------------
+ from Editeur import session
+
+ options = session.parse(sys.argv)
+ if code != None:
+ options.code = code
+ if options.fichierCata == None:
+ print("Use -c cata_name.py")
+ return
+
+ monEficasSsIhm = getEficasSsIhm(code=options.code, genereXSD=True)
+ monEditor = monEficasSsIhm.getEditor()
+ # texteXSD=monEficasSsIhm.dumpXsd(avecEltAbstrait=options.avecEltAbstrait)
+ texteXSD = monEditor.dumpXsd(avecEltAbstrait=options.avecEltAbstrait)
+
+ fichierCataTrunc = os.path.splitext(os.path.basename(options.fichierCata))[0]
+ # if fichierCataTrunc[0:4] in ('cata','Cata'): fichierCataTrunc=fichierCataTrunc[4:]
+ # if fichierCataTrunc[0] in ('_','-') : fichierCataTrunc=fichierCataTrunc[1:]
+ fileXSD = fichierCataTrunc + ".xsd"
+
+ f = open(str(fileXSD), "w")
+ f.write(str(texteXSD))
+
+
+def genereXML(code=None):
+ # -----------------------
+ from Editeur import session
+
+ options = session.parse(sys.argv)
+ if code != None:
+ options.code = code
+ if options.fichierCata == None:
+ print("Use -c cata_name.py")
+ return
+ try:
+ fichier = options.comm[0]
+ except:
+ fichier = None
+ if fichier == None:
+ print("comm file is needed")
+ return
+
+ monEficasSsIhm = getEficasSsIhm(code=options.code, forceXML=True)
+
+ from .editorSsIhm import JDCEditorSsIhm
+
+ monEditeur = JDCEditorSsIhm(monEficasSsIhm, fichier)
+ if options.fichierXMLOut == None:
+ fichierXMLOut = fichier[: fichier.rfind(".")] + ".xml"
+ else:
+ fichierXMLOut = options.fichierXMLOut
+ if not (monEditeur.jdc.isValid()):
+ print("Fichier comm is not valid")
+ return
+ # print ('Fichier comm is not valid')
+ monEditeur.XMLgenerator.gener(monEditeur.jdc)
+ monEditeur.XMLgenerator.writeDefault(fichierXMLOut)
+
+
+def genereStructure(code=None):
+ # ------------------------------
+ from Editeur import session
+
+ options = session.parse(sys.argv)
+ if code != None:
+ options.code = code
+ if options.fichierCata == None:
+ print("Use -c cata_name.py")
+ return
+
+ monEficasSsIhm = getEficasSsIhm(code=options.code, genereXSD=True)
+ monEditor = monEficasSsIhm.getEditor()
+ texteStructure = monEditor.dumpStructure()
+
+ fichierCataTrunc = os.path.splitext(os.path.basename(options.fichierCata))[0]
+ fileStructure = fichierCataTrunc + ".txt"
+ f = open(str(fileStructure), "w")
+ f.write(str(texteStructure))
+ f.close()
+
+
+def validateDataSet(code=None):
+ # ------------------------------
+ from Editeur import session
+
+ options = session.parse(sys.argv)
+ if code != None:
+ options.code = code
+ if options.fichierCata == None:
+ print("Use -c cata_name.py")
+ return
+ fichier = options.comm[0]
+ if fichier == None:
+ print("comm file is needed")
+ return
+ from .editorSsIhm import JDCEditorSsIhm
+
+ monEficasSsIhm = getEficasSsIhm(code=options.code)
+ monEditeur = JDCEditorSsIhm(monEficasSsIhm, fichier)
+ if not (monEditeur.jdc.isValid()):
+ print(monEditeur.getJdcRapport())
+ else:
+ print("Jdc is valid")
+ return monEditeur.jdc.isValid()
+
+
+def validateFonction(laFonction, debug=False):
+ # -------------------------------
+ # ici un singleton pour avoir l editor, le catalogue et...
+ monEficasSsIhm = getEficasSsIhm(code="Essai")
+ monEditor = monEficasSsIhm.getEditor()
+ print("_______ validateFonction", laFonction, laFonction.__name__)
+ from functools import wraps
+ from collections import OrderedDict
+ from inspect import getargspec
+
+ @wraps(laFonction)
+ def fonctionValidee(*args, **kwargs):
+ laFonctionName = laFonction.__name__
+ if debug:
+ print(
+ "Appel {} avec args={} et kwargs={}".format(
+ laFonction.__name__, args, kwargs
+ )
+ )
+ laDefDeLaFonctionDansAccas = getattr(monEditor.readercata.cata, laFonctionName)
+ objConstruit = laDefDeLaFonctionDansAccas.makeObjetPourVerifSignature(
+ *args, **kwargs
+ )
+ if objConstruit.isValid():
+ ret = laFonction(*args, **kwargs)
+ return ret
+ else:
+ print("mauvais arguments")
+ print(objConstruit.CR())
+ return None
+
+ return fonctionValidee
+
+ # maClasseAccas=getattr(self.cata,objEtape.monNomClasseAccas)
+ return fonctionValidee
+
+ return laFonction
+
+
+def createFromDocumentAccas(fichierCata=None, fichier=None, code=None):
+ # ------------------------------------------------------------
+ if fichier == None:
+ print("file is needed")
+ return None
+ if fichierCata == None:
+ print("cata file is needed")
+ return None
+
+ from Noyau.N_OBJECT import activeSurcharge
+
+ activeSurcharge()
+
+ from .editorSsIhm import JDCEditorSsIhm
+
+ monEficasSsIhm = getEficasSsIhm(code="Essai", fichierCata=fichierCata)
+ monEditeur = JDCEditorSsIhm(monEficasSsIhm, fichier)
+ return monEditeur.jdc
+ # from Noyau
+
+
+# --------------------------- toutes les fonctions après sont obseletes
+def lanceEficas_ssIhm(
+ code=None, fichier=None, ssCode=None, version=None, debug=False, langue="en"
+):
+ """
+ Lance l'appli EFICAS SsIhm
+ """
+ # Analyse des arguments de la ligne de commande
+ print("deprecated")
+ from Editeur import session
+
+ options = session.parse(sys.argv)
+ if version != None and options.version == None:
+ options.version = version
+ if fichier == None:
+ fichier = options.comm[0]
+ if code == None:
+ code = options.code
+
+ from .qtEficas import Appli
+
+ Eficas = Appli(code=code, salome=0, ssCode=ssCode, ssIhm=True, langue=langue)
+
+ from .ssIhm import QWParentSSIhm
+
+ parent = QWParentSSIhm(code, Eficas, version)
+
+ from . import readercata
+
+ if not hasattr(Eficas, "readercata"):
+ monreadercata = readercata.ReaderCata(parent, Eficas)
+ Eficas.readercata = monreadercata
+
+ from .editor import JDCEditor
+
+ monEditeur = JDCEditor(Eficas, fichier)
+ return monEditeur
+
+
+def lanceEficas_ssIhm_chercheGroupes(
+ code=None, fichier=None, ssCode=None, version=None
+):
+ print("deprecated")
+ monEditeur = lanceEficas_ssIhm(code, fichier, ssCode, version)
+ print((monEditeur.chercheGroupes()))
+
+
+def lanceEficas_ssIhm_cherche_cr(code=None, fichier=None, ssCode=None, version=None):
+ print("deprecated")
+ monEditeur = lanceEficas_ssIhm(code, fichier, ssCode, version)
+ print((monEditeur.jdc.cr))
+
+
+def lanceEficas_ssIhm_reecrit(
+ code=None,
+ fichier=None,
+ ssCode=None,
+ version=None,
+ ou=None,
+ cr=False,
+ debug=False,
+ leger=False,
+ langue="ang",
+):
+ print("deprecated")
+ # print 'lanceEficas_ssIhm_reecrit', fichier
+ monEditeur = lanceEficas_ssIhm(code, fichier, ssCode, version, langue=langue)
+ if ou == None:
+ fileName = fichier.split(".")[0] + "_reecrit.comm"
+ fn = fichier.split(".")[0] + "_cr.txt"
+ else:
+ f = fichier.split(".")[0] + "_reecrit.comm"
+ f1 = os.path.basename(f)
+ fn = fichier.split(".")[0] + "_cr.txt"
+ f2 = os.path.basename(fn)
+ fileName = os.path.join(ou, f1)
+ fileCr = os.path.join(ou, f2)
+ debut = False
+ if debug:
+ import cProfile, pstats, StringIO
+
+ pr = cProfile.Profile()
+ pr.enable()
+ monEditeur.saveFileAs(fileName=fileName)
+ pr.disable()
+ s = StringIO.StringIO()
+ sortby = "cumulative"
+ ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
+ ps.print_stats()
+ print(s.getValue())
+
+ elif not leger:
+ monEditeur.saveFileAs(fileName=fileName)
+ else:
+ monEditeur.saveFileLegerAs(fileName=fileName)
+ if cr:
+ f = open(fileCr, "w")
+ f.write(str(monEditeur.jdc.report()))
+ f.close()
+
+
+def lanceEficas_param(
+ code="Adao", fichier=None, version="V0", macro="ASSIMILATION_STUDY"
+):
+ """
+ Lance l'appli EFICAS pour trouver les noms des groupes
+ """
+ print("deprecated")
+ # Analyse des arguments de la ligne de commande
+ from Editeur import session
+
+ options = session.parse(sys.argv)
+
+ from .qtEficas import Appli
+
+ from .ssIhm import QWParentSSIhm
+
+ Eficas = QWParentSSIhm(code, version)
+
+ from . import readercata
+
+ if not hasattr(Eficas, "readercata"):
+ monreadercata = readercata.ReaderCata(parent, Eficas)
+ Eficas.readercata = monreadercata
+
+ from .editor import JDCEditor
+
+ monEditeur = JDCEditor(Eficas, fichier)
+ texte = loadJDC(fichier)
+ parameters = getJdcParameters(texte, macro)
+ return parameters
+
+
+def getJdcParameters(jdc, macro):
+ """
+ This function converts the data from the specified macro of the
+ specified jdc text to a python dictionnary whose keys are the
+ names of the data of the macro.
+ """
+ print("deprecated")
+ context = {}
+ source = "def args_to_dict(**kwargs): return kwargs \n"
+ source += "%s = _F = args_to_dict \n" % macro
+ source += "parameters=" + jdc + " \n"
+ source += "context['parameters'] = parameters \n"
+ code = compile(source, "file.py", "exec")
+ eval(code)
+ parameters = context["parameters"]
+ return parameters
+
+
+def loadJDC(filename):
+ """
+ This function loads the text from the specified JdC file. A JdC
+ file is the persistence file of Eficas (*.comm).
+ """
+ print("deprecated")
+ fcomm = open(filename, "r")
+ jdc = ""
+ for line in fcomm.readlines():
+ if not (line[0] == "#"):
+ jdc += "%s" % line
+
+ # Warning, we have to make sure that the jdc comes as a simple
+ # string without any extra spaces/newlines
+ return jdc.strip()
+
+
+if __name__ == "__main__":
+ import sys
+
+ sys.path.insert(0, os.path.abspath(os.path.join(os.getcwd(), "..")))
+ lanceEficas(code=None, multi=True)
diff --git a/Extensions/acquiertGroupes.py b/Extensions/acquiertGroupes.py
new file mode 100755
index 00000000..35eb0918
--- /dev/null
+++ b/Extensions/acquiertGroupes.py
@@ -0,0 +1,123 @@
+#! /usr/bin/env python
+# -*- coding:utf-8 -*-
+# /* This file is part of MED.
+# *
+# * COPYRIGHT (C) 1999 - 2013 EDF R&D, CEA/DEN
+# * MED 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 3 of the License, or
+# * (at your option) any later version.
+# *
+# * MED 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 MED. If not, see .
+# */
+
+
+import sys
+sys.path.append('/home/A96028/Salome/V7_main/tools/install/Medfichier-307-hdf51810/lib/python2.7/site-packages')
+
+from med.medfile import *
+from med.medmesh import *
+from med.medfamily import *
+from med.medfilter import *
+
+
+def getGroupes(filename,debug=0) :
+ listeGroupes=[]
+ maa=""
+
+ dicoNumFam={}
+
+ try :
+ fid = MEDfileOpen(filename,MED_ACC_RDONLY)
+ except :
+ return ("Pb a la lecture du fichier", listeGroupes,maa)
+
+
+ # /* Lecture des infos concernant le premier maillage */
+ maa, sdim, mdim, type, desc, dtunit, sort, nstep, rep, nomcoo,unicoo = MEDmeshInfo(fid, 1)
+ if debug :
+ print "Maillage de nom : |%s| de dimension : %ld , et de type %s\n"%(maa,mdim,type)
+ print "Maillage de nom : |%s| , de dimension : %ld , et de type %s\n"%(maa,mdim,type)
+ print "\t -Dimension de l'espace : %ld\n"%(sdim)
+ print "\t -Description du maillage : %s\n"%(desc)
+ print "\t -Noms des axes : |%s|\n"%(nomcoo)
+ print "\t -Unités des axes : |%s|\n"%(unicoo)
+ print "\t -Type de repère : %s\n"%(rep)
+ print "\t -Nombre d'étape de calcul : %ld\n"%(nstep)
+ print "\t -Unité des dates : |%s|\n"%(dtunit)
+
+ # /* Lecture du nombre de familles */
+ nfam = MEDnFamily(fid,maa)
+ if debug :
+ print "Nombre de familles : %d \n"%(nfam)
+
+ # /* Lecture de chaque famille */
+ for i in xrange(0,nfam):
+
+ # /* Lecture du nombre de groupe */
+ ngro = MEDnFamilyGroup(fid,maa,i+1)
+ if debug :
+ print "Famille %d a %d groupes \n"%(i+1,ngro)
+
+ gro = MEDCHAR(MED_LNAME_SIZE*ngro+1)
+
+ nomfam,numfam,gro = MEDfamilyInfo(fid,maa,i+1,gro)
+ if debug :
+ print "Famille de nom %s et de numero %d : \n"%(nomfam,numfam)
+ print "Attributs : \n"
+
+ for j in xrange(0,ngro):
+ # print "gro = %s\n"%(gro[j*MED_LNAME_SIZE:j*MED_LNAME_SIZE+MED_LNAME_SIZE])
+ groupSplit=gro[j*MED_LNAME_SIZE:j*MED_LNAME_SIZE+MED_LNAME_SIZE]
+ groupeName="".join(groupSplit).split("\x00")[0]
+ groupeName=groupeName.replace(' ','')
+ if groupeName[0:7]=="CENTRE_" : dicoNumFam[groupeName]=numfam
+ if groupeName not in listeGroupes : listeGroupes.append(groupeName)
+
+
+ #print dicoNumFam
+ #print listeGroupes
+
+ # /* Lecture des Numeros de Familles */
+
+ nnoe, chgt, trsf = MEDmeshnEntity(fid,maa,MED_NO_DT,MED_NO_IT, MED_NODE,MED_NONE,MED_COORDINATE,MED_NO_CMODE)
+ nufano = MEDINT(nnoe)
+ MEDmeshEntityFamilyNumberRd(fid,maa, MED_NO_DT, MED_NO_IT, MED_NODE,MED_NONE,nufano)
+ dicoNumNode={}
+ for groupe in dicoNumFam.keys():
+ famille=dicoNumFam[groupe]
+ i=0
+ while i < nufano.size():
+ if nufano[i]==famille :
+ dicoNumNode[groupe]=i+1
+ break
+ i=i+1
+
+
+ #print dicoNumNode
+ dicoCoord={}
+ for groupe in dicoNumNode.keys() :
+ flt=MEDINT(1)
+ flt[0]=dicoNumNode[groupe]
+ coo1=MEDFLOAT(3)
+ filter=med_filter()
+ err=MEDfilterEntityCr( fid, nnoe, 1, sdim, MED_ALL_CONSTITUENT, MED_FULL_INTERLACE, MED_COMPACT_PFLMODE, MED_NO_PROFILE,1 , flt, filter)
+ MEDmeshNodeCoordinateAdvancedRd(fid, maa, MED_NO_DT, MED_NO_IT, filter, coo1)
+ MEDfilterClose(filter)
+ dicoCoord[groupe]=coo1
+# dicoCoord['CENTRE_saxBas']=(0,0,28.5e-3)
+# dicoCoord['CENTRE_saxHaut']=(0,0,31.5e-3)
+
+ MEDfileClose(fid)
+ return ("",listeGroupes,maa,dicoCoord)
+
+if __name__ == "__main__":
+ filename="/home/A96028/Carmel/Pascale/Domaine_Bidouille.med"
+ #filename="/home/A96028/Carmel/nouveauMed/Domaine.med"
+ print getGroupes(filename)
diff --git a/InterfaceGUI/.a.swp b/InterfaceGUI/.a.swp
new file mode 100644
index 00000000..297cd885
Binary files /dev/null and b/InterfaceGUI/.a.swp differ
diff --git a/InterfaceGUI/QT5/__init__.py b/InterfaceGUI/QT5/__init__.py
new file mode 100644
index 00000000..24d44c17
--- /dev/null
+++ b/InterfaceGUI/QT5/__init__.py
@@ -0,0 +1,23 @@
+# -*- 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
+#
+"""
+ Ce package contient les fonctionnalites necessaires
+ pour l'editeur graphique QT
+"""
diff --git a/InterfaceGUI/QT5/browser.py b/InterfaceGUI/QT5/browser.py
new file mode 100644
index 00000000..fba2d783
--- /dev/null
+++ b/InterfaceGUI/QT5/browser.py
@@ -0,0 +1,1173 @@
+# -*- 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 re
+import types, sys, os
+import traceback
+from . import typeNode
+
+
+from PyQt5.QtWidgets import QTreeWidget, QTreeWidgetItem, QApplication, QMessageBox
+from PyQt5.QtGui import QIcon
+from PyQt5.QtCore import Qt
+
+from Extensions.i18n import tr
+from .gereRegles import GereRegles
+from .monChoixCommande import MonChoixCommande
+
+
+# ------------------------------------------
+class JDCTree(QTreeWidget, GereRegles):
+# ------------------------------------------
+
+ def __init__(self, jdc_item, QWParent):
+ # ----------------------------------------
+ self.editor = QWParent
+ self.plie = False
+ if self.editor.widgetTree != None:
+ QTreeWidget.__init__(self, self.editor.widgetTree)
+ self.editor.verticalLayout_2.addWidget(self)
+ if self.editor.enteteQTree == "complet":
+ self.headerItem().setText(0, "Commande ")
+ self.headerItem().setText(1, "Concept/Valeur")
+ else:
+ self.headerItem().setText(0, "Commande ")
+ self.setColumnWidth(0, 200)
+ self.setExpandsOnDoubleClick(False)
+ self.setSelectionMode(3)
+ else:
+ QTreeWidget.__init__(self, None)
+ self.item = jdc_item
+ self.tree = self
+ self.appliEficas = self.editor.appliEficas
+ self.childrenComplete = []
+ self.racine = self.item.itemNode(self, self.item)
+
+ self.itemCourant = None
+
+ self.itemClicked.connect(self.handleOnItem)
+ self.itemCollapsed.connect(self.handleCollapsedItem)
+ self.itemExpanded.connect(self.handleExpandedItem)
+
+ self.node_selected = self.racine
+ self.inhibeExpand = True
+ self.expandItem(self.racine)
+ self.inhibeExpand = False
+ if self.racine.children != []:
+ if self.editor.maConfiguration.afficheCommandesPliees:
+ self.racine.children[0].plieToutEtReaffiche()
+ else:
+ self.racine.children[0].deplieToutEtReaffiche()
+ self.racine.children[0].fenetre.donnePremier()
+ else:
+ self.racine.affichePanneau()
+
+ def contextMenuEvent(self, event):
+ # ---------------------------------
+ coord = event.globalPos()
+ item = self.currentItem()
+ self.handleContextMenu(item, coord)
+
+ def handleContextMenu(self, item, coord):
+ # -------------------------------------
+ """
+ Private slot to show the context menu of the listview.
+
+ @param itm the selected listview item (QListWidgetItem)
+ @param coord the position of the mouse pointer (QPoint)
+ Attention : existeMenu permet de savoir si un menu est associe a cet item
+ """
+ print("handleContextMenu")
+ if item == None:
+ return
+ self.itemCourant = item
+ if item.existeMenu == 0:
+ return
+
+ if item.menu == None:
+ item.createPopUpMenu()
+ if item.menu != None:
+ # PNPN reflechir a qqchose de generique pour remplacer cette fonctionnalite
+ # if item.item.getNom() == "DISTRIBUTION" and item.item.isValid() :
+ # item.Graphe.setEnabled(1)
+ item.menu.exec_(coord)
+
+ def handleCollapsedItem(self, item):
+ # ----------------------------------
+ # print ("dans CollapsedItem", self.inhibeExpand )
+ if self.inhibeExpand == True:
+ return
+
+ # On traite le cas de l item non selectionne
+ self.itemCourant = item
+ itemParent = item
+ while not (hasattr(itemParent, "getPanel")):
+ itemParent = itemParent.treeParent
+ if self.tree.node_selected != itemParent:
+ item.setExpanded(False)
+ return
+
+ item.setPlie()
+ item.plieToutEtReaffiche()
+ item.select()
+
+ def handleExpandedItem(self, item):
+ # ----------------------------------
+ # print ("handleExpandedItem pour ", item.item.nom, self.inhibeExpand)
+ # import traceback
+ # traceback.print_stack()
+ if self.inhibeExpand == True:
+ return
+
+ self.itemCourant = item
+ self.inhibeExpand = True
+ itemParent = item
+ while not (hasattr(itemParent, "getPanel")):
+ if itemParent.plie == True:
+ itemParent.setDeplie()
+ itemParent = itemParent.treeParent
+ if self.tree.node_selected != itemParent:
+ item.setExpanded(True)
+ self.inhibeExpand = False
+ return
+ item.deplieToutEtReaffiche()
+ self.inhibeExpand = False
+
+ def handleOnItem(self, item, int):
+ # ----------------------------------
+ # print ("je passe dans handleOnItem pour ",self, item.item.nom, item, item.item, item.item.getLabelText())
+
+ from InterfaceGUI.QT5 import composimp
+
+ self.inhibeExpand = True
+ self.itemCourant = item
+ itemParent = item
+ itemAvant = item
+
+ # PN : 22 juil 2021 --> bizarre ce itemAvant Verifier le while
+ while not (hasattr(itemParent, "getPanel")):
+ if itemParent.plie == True:
+ itemParent.setDeplie()
+ itemAvant = itemParent
+ itemParent = itemParent.treeParent
+
+ if itemParent.fenetre != self.editor.fenetreCentraleAffichee:
+ estUneFeuille = isinstance(item, composimp.Node)
+ # il faut afficher le parent
+ # Attention - Specification particuliere pour MT qui permet de nn afficher qu 1 niveau
+ # le catalogue contient cette indication dans fenetreIhm
+ if estUneFeuille and itemParent.fenetreIhm == "deplie1Niveau":
+ if item == itemParent:
+ itemParent.affichePanneau()
+ else:
+ itemAvant.afficheCeNiveau()
+ elif estUneFeuille:
+ itemParent.affichePanneau()
+ elif self.editor.maConfiguration.afficheCommandesPliees:
+ itemParent.plieToutEtReafficheSaufItem(item)
+ else:
+ itemParent.affichePanneau()
+
+ elif (isinstance(item, composimp.Node)) and item.fenetre:
+ item.fenetre.rendVisible()
+ elif itemParent != item:
+ self.tree.handleExpandedItem(item)
+
+ # aide
+ try:
+ fr = item.item.getFr()
+ chaineDecoupee = fr.split("\n")
+ if len(chaineDecoupee) > 3:
+ txt = (
+ "\n".join(chaineDecoupee[0:2])
+ + "...\nfull help : double clicked on validity chip of "
+ + str(item.item.nom)
+ + " in central widget"
+ )
+ else:
+ txt = fr
+ if self.editor:
+ self.editor.afficheCommentaire(str(txt))
+ except:
+ pass
+
+ item.select()
+ self.inhibeExpand = False
+
+ def choisitPremier(self, name):
+ # ----------------------------
+ self.editor.layoutJDCCHOIX.removeWidget(self.racine.fenetre)
+ self.racine.fenetre.close()
+ new_node = self.racine.appendBrother(name, "after")
+
+
+# type de noeud
+COMMENT = "COMMENTAIRE"
+PARAMETERS = "PARAMETRE"
+
+
+# ------------------------------------------
+class JDCNode(QTreeWidgetItem, GereRegles):
+# ------------------------------------------
+ def __init__(self, treeParent, item, itemExpand=False, ancien=False):
+ # ----------------------------------------------------------------------
+ # print ("creation d'un noeud : ", item, " ",item.nom,"", treeParent, self)
+ # self.a=0
+
+ self.item = item
+ self.vraiParent = treeParent
+ self.treeParent = treeParent
+ self.tree = self.treeParent.tree
+ self.editor = self.treeParent.editor
+ self.appliEficas = treeParent.appliEficas
+ self.JESUISOFF = 0
+ self.firstAffiche = True
+ self.childrenComplete = []
+ self.item._object.node = self
+
+ from InterfaceGUI.QT5 import compocomm
+ from InterfaceGUI.QT5 import compoparam
+ from InterfaceGUI.QT5 import composimp
+
+ if isinstance(self.item, compocomm.COMMTreeItem):
+ name = tr("Commentaire")
+ elif isinstance(self.item, compoparam.PARAMTreeItem):
+ name = tr(str(item.getLabelText()[0]))
+ else:
+ name = tr(item.getLabelText()[0])
+ if item.nom != tr(item.nom):
+ name = str(tr(item.nom) + " :")
+ value = tr(str(item.getText()))
+
+ # si specialisation de la fenetre
+ if self.item.object.definition == None:
+ self.fenetreIhm = None
+ # Cas des listes de mots_clefs
+ else:
+ self.fenetreIhm = self.item.object.definition.fenetreIhm
+
+ if self.editor.enteteQTree == "complet":
+ mesColonnes = (name, value)
+ else:
+ mesColonnes = (name,)
+
+ if self.treeParent.plie == True:
+ self.plie = True
+ self.appartientAUnNoeudPlie = True
+ if self.treeParent.item.isMCList():
+ self.appartientAUnNoeudPlie = self.treeParent.appartientAUnNoeudPlie
+ else:
+ self.plie = False
+ self.appartientAUnNoeudPlie = False
+
+ # if item.nom == "POUTRE" :print "creation d'un noeud : ", item, " ",item.nom,"", self.treeParent, self.appartientAUnNoeudPlie , self.plie
+
+ if ancien and itemExpand:
+ self.plie = False
+ if ancien and not itemExpand:
+ self.plie = True
+ if isinstance(self.item, composimp.SIMPTreeItem):
+ self.plie = False
+
+ from InterfaceGUI.QT5 import compobloc
+ from InterfaceGUI.QT5 import compomclist
+
+ ajoutAuParentduNoeud = 0
+ self.treeParent = treeParent
+ while isinstance(self.treeParent, compobloc.Node) or (
+ isinstance(self.treeParent, compomclist.Node)
+ and self.treeParent.item.isMCList()
+ ):
+ self.treeParent.childrenComplete.append(self)
+ self.treeParent = self.treeParent.vraiParent
+ self.treeParent.childrenComplete.append(self)
+
+ if (
+ isinstance(self, compobloc.Node)
+ or (isinstance(self, compomclist.Node) and self.item.isMCList())
+ or (
+ hasattr(self.item.parent, "inhibeValidator")
+ and isinstance(self, compomclist.Node)
+ and self.item.parent.inhibeValidator
+ )
+ or (
+ isinstance(self, composimp.Node)
+ and self.item.definition.statut in ("c", "d")
+ )
+ ):
+ # Le dernier or ne sert que lorsqu'on est en train de creer une liste par les validator
+ QTreeWidgetItem.__init__(self, None, mesColonnes)
+ else:
+ QTreeWidgetItem.__init__(self, self.treeParent, mesColonnes)
+
+ self.setToolTip(0, self.item.getFr())
+ self.setToolTip(1, self.item.getFr())
+ repIcon = self.appliEficas.repIcon
+
+ couleur = self.item.getIconName()
+ monIcone = QIcon(repIcon + "/" + couleur + ".png")
+
+ self.setIcon(0, monIcone)
+
+ self.children = []
+ self.buildChildren()
+ self.menu = None
+ self.existeMenu = 1
+
+ self.item.connect("valid", self.onValid, ())
+ self.item.connect("supp", self.onSupp, ())
+ self.item.connect("add", self.onAdd, ())
+ self.item.connect("redessine", self.onRedessine, ())
+
+ self.state = ""
+ self.fenetre = None
+ try:
+ if self.item.getObject().isBLOC():
+ self.setExpanded(True)
+ self.plie = False
+ except:
+ pass
+
+ def buildChildren(self, posInsertion=10000):
+ # ------------------------------------------
+ """Construit la liste des enfants de self"""
+ """ Se charge de remettre les noeuds Expanded dans le meme etat """
+ # print ("*********** buildChildren ",self,self.item, self.item.nom)
+ # print (poum)
+
+ self.listeItemExpanded = []
+ self.listeItemPlie = []
+
+ for enfant in self.childrenComplete:
+ if enfant.plie:
+ self.listeItemPlie.append(enfant.item)
+ else:
+ self.listeItemExpanded.append(enfant.item)
+
+ for enfant in self.childrenComplete:
+ parent = enfant.treeParent
+ parent.removeChild(enfant)
+ enfant.JESUISOFF = 1
+
+ self.children = []
+ self.childrenComplete = []
+ sublist = self.item._getSubList()
+ ind = 0
+
+ for item in sublist:
+ itemExpand = False
+ ancien = False
+ if item in self.listeItemExpanded:
+ itemExpand = True
+ ancien = True
+ if item in self.listeItemPlie:
+ itemExpand = False
+ ancien = True
+ nouvelItem = item.itemNode(self, item, itemExpand, ancien)
+ self.children.append(nouvelItem)
+
+ # print ("fin *********** buildChildren ",self,self.item, self.item.nom, self.children)
+
+ def chercheNoeudCorrespondant(self, objSimp):
+ # -------------------------------------------
+ sublist = self.item._getSubList()
+ for node in self.childrenComplete:
+ if node.item.object == objSimp:
+ return node
+ return None
+
+ def afficheCeNiveau(self):
+ # -------------------------
+ # print ('afficheCeNiveau pour ', self.item.nom, self.item.getLabelText())
+ for indiceWidget in range(self.editor.widgetCentraleLayout.count()):
+ widget = self.editor.widgetCentraleLayout.itemAt(indiceWidget)
+ self.editor.widgetCentraleLayout.removeItem(widget)
+ if self.editor.fenetreCentraleAffichee != None:
+ self.editor.widgetCentraleLayout.removeWidget(
+ self.editor.fenetreCentraleAffichee
+ )
+ self.editor.fenetreCentraleAffichee.setParent(None)
+ self.editor.fenetreCentraleAffichee.close()
+ self.editor.fenetreCentraleAffichee.deleteLater()
+
+ from monWidgetNiveauFact import MonWidgetNiveauFact, MonWidgetNiveauFactTableau
+
+ maDefinition = self.item.get_definition()
+ monObjet = self.item.object
+ if maDefinition.fenetreIhm == "Tableau":
+ self.maFenetreCadre = MonWidgetNiveauFactTableau(
+ self, self.editor, maDefinition, monObjet
+ )
+ else:
+ self.maFenetreCadre = MonWidgetNiveauFact(
+ self, self.editor, maDefinition, monObjet
+ )
+
+ self.fenetre = self.maFenetreCadre
+ self.editor.widgetCentraleLayout.addWidget(self.maFenetreCadre)
+ self.editor.fenetreCentraleAffichee = self.maFenetreCadre
+ self.select()
+ # print ('fin afficheCeNiveau pour ', self.item.nom)
+
+ def getPanelModifie(self):
+ # -------------------------
+
+ if self.fenetreIhm == None:
+ return None
+ if self.fenetreIhm == "deplie1Niveau":
+ from InterfaceGUI.QT5.monWidgetCommandeDeplie1Niveau import (
+ MonWidgetCommandeDeplie1Niveau,
+ )
+
+ return MonWidgetCommandeDeplie1Niveau(self, self.editor, self.item.object)
+ return None
+
+ def affichePanneau(self):
+ # -------------------------
+ # print ('_________________ds affichePanneau pour', self.item.nom)
+ # pour l instant pas d inactif
+ if not (self.item.isActif()):
+ from .monWidgetInactif import MonWidgetInactif
+
+ self.fenetre = MonWidgetInactif(self, self.editor)
+ else:
+ itemParent = self
+ while not (hasattr(itemParent, "getPanel")):
+ itemParent = itemParent.treeParent
+ if itemParent != self:
+ # print ('j appelle affichePanneau pour ', itemParent.item.nom , 'par', self.item.nom)
+ itemParent.affichePanneau()
+ # print ('fin _________________ds affichePanneau pour', self.item.nom)
+ return
+
+ self.fenetre = self.getPanelModifie()
+ if self.fenetre == None:
+ self.fenetre = self.getPanel()
+ self.editor.restoreSplitterSizes()
+
+ for indiceWidget in range(self.editor.widgetCentraleLayout.count()):
+ widget = self.editor.widgetCentraleLayout.itemAt(indiceWidget)
+ self.editor.widgetCentraleLayout.removeItem(widget)
+
+ # ceinture et bretelle
+ # print 'old fenetre = ',self.editor.fenetreCentraleAffichee
+ if self.editor.fenetreCentraleAffichee != None:
+ try:
+ self.editor.widgetCentraleLayout.removeWidget(
+ self.editor.fenetreCentraleAffichee
+ )
+ self.editor.fenetreCentraleAffichee.setParent(None)
+ self.editor.fenetreCentraleAffichee.close()
+ self.editor.fenetreCentraleAffichee.deleteLater()
+ # print ('en sortie du try sur la vieille fenetre')
+ except:
+ pass
+
+ self.editor.widgetCentraleLayout.addWidget(self.fenetre)
+ # print ("j ajoute ", self.fenetre, self.fenetre.node.item.nom)
+ self.editor.fenetreCentraleAffichee = self.fenetre
+ self.tree.node_selected = self
+
+ if self.editor.first:
+ if not (isinstance(self.fenetre, MonChoixCommande)):
+ self.editor.first = False
+ self.tree.inhibeExpand = True
+ self.tree.expandItem(self)
+ self.tree.inhibeExpand = False
+ # print( '_________________fin affichePanneau pour', self.item.nom)
+
+ def createPopUpMenu(self):
+ # -------------------------
+ # implemente dans les noeuds derives si necessaire
+ self.existeMenu = 0
+
+ def commentIt(self):
+ # -------------------------
+ """
+ Cette methode a pour but de commentariser la commande pointee par self
+ """
+ # On traite par une exception le cas ou l'utilisateur final cherche a desactiver
+ # (commentariser) un commentaire.
+ try:
+ pos = self.treeParent.children.index(self)
+ commande_comment = self.item.getObjetCommentarise()
+ # On signale a l editeur du panel (le JDCDisplay) une modification
+ self.editor.initModif()
+ self.treeParent.buildChildren()
+ self.treeParent.children[pos].select()
+ self.treeParent.children[pos].affichePanneau()
+ except Exception as e:
+ traceback.print_exc()
+ QMessageBox.critical(self.editor, "TOO BAD", str(e))
+
+ def unCommentIt(self):
+ # -------------------------
+ """
+ Realise la decommentarisation de self
+ """
+ try:
+ pos = self.treeParent.children.index(self)
+ commande, nom = self.item.unComment()
+ self.editor.initModif()
+ self.treeParent.buildChildren()
+ self.treeParent.children[pos].select()
+ self.treeParent.children[pos].affichePanneau()
+ except Exception as e:
+ QMessageBox.critical(self.editor, "Erreur !", str(e))
+
+ def addComment(self, after=True):
+ # -----------------------------------
+ """
+ Ajoute un commentaire a l'interieur du JDC :
+ """
+ self.editor.initModif()
+ if after:
+ pos = "after"
+ else:
+ pos = "before"
+ return self.appendBrother(COMMENT, pos)
+
+ def addParameters(self, after=True):
+ # -------------------------------------
+ """
+ Ajoute un parametre a l'interieur du JDC :
+ """
+ self.editor.initModif()
+ if after:
+ pos = "after"
+ else:
+ pos = "before"
+ child = self.appendBrother(PARAMETERS, pos)
+ return child
+
+ def select(self):
+ # ------------------
+ """
+ Rend le noeud courant (self) selectionne et deselectionne
+ tous les autres
+ """
+ # print "select pour", self.item.nom
+ for item in self.tree.selectedItems():
+ item.setSelected(0)
+ self.tree.setCurrentItem(self)
+
+ # ------------------------------------------------------------------
+ # Methodes de creation et destruction de noeuds
+ # ------------------------------------------------------------------
+
+ def appendBrother(self, name, pos="after", plier=False):
+ # ----------------------------------------------------
+ """
+ Permet d'ajouter un objet frere a l'objet associe au noeud self
+ par defaut on l'ajoute immediatement apres
+ Methode externe
+ """
+ self.editor.initModif()
+
+ from InterfaceGUI.QT5 import compojdc
+
+ if (isinstance(self.treeParent, compojdc.Node)) and not self.verifiePosition(
+ name, pos
+ ):
+ return 0
+
+ if self.treeParent != self.vraiParent:
+ index = self.vraiParent.children.index(self)
+ if pos == "before":
+ index = index
+ elif pos == "after":
+ index = index + 1
+ return self.vraiParent.appendChild(name, pos=index, plier=plier)
+ else:
+ index = self.treeParent.children.index(self)
+ if pos == "before":
+ index = index
+ elif pos == "after":
+ index = index + 1
+ else:
+ print(pos, tr(" n'est pas un index valide pour appendBrother"))
+ return 0
+ return self.treeParent.appendChild(name, pos=index, plier=plier)
+
+ def verifiePosition(self, name, pos, aLaRacine=False):
+ # ----------------------------------------------------
+ if name not in self.editor.readercata.Classement_Commandes_Ds_Arbre:
+ return True
+ indexName = self.editor.readercata.Classement_Commandes_Ds_Arbre.index(name)
+
+ etapes = self.item.getJdc().etapes
+ if etapes == []:
+ return True
+
+ if aLaRacine == False:
+ indexOu = etapes.index(self.item.object)
+ else:
+ indexOu = 0
+
+ if pos == "after":
+ indexOu = indexOu + 1
+ for e in etapes[:indexOu]:
+ nom = e.nom
+ if nom not in self.editor.readercata.Classement_Commandes_Ds_Arbre:
+ continue
+ indexEtape = self.editor.readercata.Classement_Commandes_Ds_Arbre.index(nom)
+ if indexEtape > indexName:
+ comment = (
+ tr("le mot clef ") + name + tr(" doit etre insere avant ") + nom
+ )
+ QMessageBox.information(
+ None,
+ tr("insertion impossible"),
+ comment,
+ )
+ return False
+ for e in etapes[indexOu:]:
+ nom = e.nom
+ if nom not in self.editor.readercata.Classement_Commandes_Ds_Arbre:
+ continue
+ indexEtape = self.editor.readercata.Classement_Commandes_Ds_Arbre.index(nom)
+ if indexEtape < indexName:
+ comment = (
+ tr("le mot clef ") + name + tr(" doit etre insere apres ") + nom
+ )
+ QMessageBox.information(
+ None,
+ tr("insertion impossible"),
+ comment,
+ )
+ return False
+ return True
+
+ def appendChild(self, name, pos=None, plier=False):
+ # ------------------------------------------------
+ """
+ Methode pour ajouter un objet fils a l'objet associe au noeud self.
+ On peut l'ajouter en debut de liste (pos='first'), en fin (pos='last')
+ ou en position intermediaire.
+ Si pos vaut None, on le place a la position du catalogue.
+ """
+ # print ("************** appendChild ",self.item.getLabelText(), pos, plier)
+ # import traceback
+ # traceback.print_stack()
+
+ self.editor.initModif()
+ if pos == "first":
+ index = 0
+ elif pos == "last":
+ index = len(self.children)
+ elif type(pos) == int:
+ index = pos # position fixee
+ elif type(pos) == object:
+ index = (
+ self.item.getIndex(pos) + 1
+ ) # pos est un item. Il faut inserer name apres pos
+ elif type(name) == object:
+ index = self.item.getIndexChild(name.nom)
+ else:
+ index = self.item.getIndexChild(name)
+
+ # si on essaye d inserer a la racine
+ if isinstance(self.treeParent, JDCTree) and index == 0:
+ verifiePosition = self.verifiePosition(name, "first", aLaRacine=True)
+ if not verifiePosition:
+ return 0
+
+ self.tree.inhibeExpand = True
+ obj = self.item.addItem(name, index) # emet le signal 'add'
+ if obj is None:
+ obj = 0
+ if obj == 0:
+ return 0
+
+ try:
+ # if 1 :
+ child = self.children[index]
+ if plier == True:
+ child.setPlie()
+ else:
+ child.setDeplie()
+ except:
+ child = self.children[index]
+
+ try:
+ if len(obj) > 1:
+ self.buildChildren()
+ except:
+ pass
+
+ self.tree.inhibeExpand = False
+ # print (" fin append child")
+ return child
+
+ def deplace(self):
+ # -----------------
+ self.editor.initModif()
+ index = self.treeParent.children.index(self) - 1
+ if index < 0:
+ index = 0
+ ret = self.treeParent.item.deplaceEntite(self.item.getObject())
+
+ def delete(self):
+ # ----------------
+ """
+ Methode externe pour la destruction de l'objet associe au noeud
+ """
+ self.editor.initModif()
+ index = self.vraiParent.children.index(self) - 1
+ if index < 0:
+ index = 0
+
+ recalcule = 0
+ if self.item.nom == "VARIABLE":
+ recalcule = 1
+ jdc = self.item.jdc
+
+ ret, commentaire = self.vraiParent.item.suppItem(self.item)
+ if ret == 0:
+ self.editor.afficheInfos(commentaire, Qt.red)
+ else:
+ self.editor.afficheInfos(commentaire)
+ self.treeParent.buildChildren()
+ if self.treeParent.childrenComplete:
+ toselect = self.treeParent.childrenComplete[index]
+ else:
+ toselect = self.treeParent
+
+ if recalcule:
+ jdc.recalculeEtatCorrelation()
+ if ret == 0:
+ if self.treeParent.childrenComplete:
+ notdeleted = self.treeParent.childrenComplete[index + 1]
+ notdeleted.select()
+ else:
+ toselect.select()
+
+ from InterfaceGUI.QT5 import compojdc
+
+ # cas ou on detruit dans l arbre sans affichage
+ if isinstance(self.treeParent, compojdc.Node):
+ toselect.affichePanneau()
+ else:
+ if self.treeParent.fenetre == None:
+ return
+ # print "J appelle reaffiche de browser apres delete"
+ self.treeParent.fenetre.reaffiche(toselect)
+
+ def deleteMultiple(self, liste=()):
+ # --------------------------------
+ """
+ Methode externe pour la destruction d une liste de noeud
+ """
+ from InterfaceGUI.QT5 import compojdc
+
+ self.editor.initModif()
+ index = 9999
+ recalcule = 0
+ jdc = self.treeParent
+ parentPosition = jdc
+ while not (isinstance(jdc, compojdc.Node)):
+ jdc = jdc.treeParent
+ for noeud in liste:
+ if not (isinstance(noeud.treeParent, compojdc.Node)):
+ continue
+ if noeud.item.nom == "VARIABLE":
+ recalcule = 1
+ if noeud.treeParent.children.index(noeud) < index:
+ index = noeud.treeParent.children.index(noeud)
+ if index < 0:
+ index = 0
+
+ # Cas ou on detruit dans une ETape
+ if index == 9999:
+ parentPosition = self.treeParent
+ while not (isinstance(parentPosition, compojdc.Node)):
+ index = parentPosition.treeParent.children.index(parentPosition)
+ parentPosition = parentPosition.treeParent
+
+ for noeud in liste:
+ noeud.treeParent.item.suppItem(noeud.item)
+
+ jdc.buildChildren()
+ if recalcule:
+ jdc.recalculeEtatCorrelation()
+ try:
+ toselect = parentPosition.children[index]
+ except:
+ toselect = jdc
+ toselect.select()
+ toselect.affichePanneau()
+
+ #
+ # ------------------------------------------------------------------
+
+ def onValid(self):
+ # -----------------
+ # print ("onValid pour ", self.item.nom)
+ if self.JESUISOFF == 1:
+ return
+
+ if hasattr(self, "fenetre") and self.fenetre:
+ try:
+ self.fenetre.setValide()
+ except:
+ pass
+
+ # PNPN lignes suivantes a repenser
+ if (
+ self.item.nom == "VARIABLE" or self.item.nom == "DISTRIBUTION"
+ ) and self.item.isValid():
+ self.item.jdc.recalculeEtatCorrelation()
+ if hasattr(self.item, "forceRecalcul"):
+ self.forceRecalculChildren(self.item.forceRecalcul)
+ self.editor.initModif()
+
+ self.updateNodeValid()
+ self.updateNodeLabel()
+ self.updateNodeTexte()
+
+ def onAdd(self, object):
+ # ----------------------
+ # print ("onAdd pour ", self.item.nom, object)
+ if self.JESUISOFF == 1:
+ return
+ self.editor.initModif()
+ self.buildChildren()
+ if hasattr(self.item, "jdc"):
+ self.item.jdc.aReafficher = True
+
+ def onSupp(self, object):
+ # -----------------------
+ # print ("onSup pour ", self.item.nom, object)
+ # import traceback
+ # traceback.print_stack()
+ if self.JESUISOFF == 1:
+ return
+ self.editor.initModif()
+ self.buildChildren()
+ if hasattr(self.item, "jdc"):
+ self.item.jdc.aReafficher = True
+
+ def onRedessine(self):
+ # ---------------------
+ # print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!je passe dans onRedessine pour', self.item.nom)
+ self.affichePanneau()
+
+ def updateNodeValid(self):
+ # -----------------------
+ """Cette methode remet a jour la validite du noeud (icone)
+ Elle appelle isValid
+ """
+ repIcon = self.appliEficas.repIcon
+ couleur = self.item.getIconName()
+ monIcone = QIcon(repIcon + "/" + couleur + ".png")
+ self.setIcon(0, monIcone)
+
+ def updateNodeLabel(self):
+ # -------------------------
+ """Met a jour le label du noeud"""
+ # print ("NODE updateNodeLabel", self.item.getLabelText())
+ labeltext, fonte, couleur = self.item.getLabelText()
+ # PNPN a reflechir
+ if self.item.nom != tr(self.item.nom):
+ labeltext = str(tr(self.item.nom) + " :")
+ self.setText(0, tr(labeltext))
+
+ def updateNodeLabelInBlack(self):
+ # -------------------------------
+ if hasattr(self.appliEficas, "noeudColore"):
+ self.appliEficas.noeudColore.setForeground(0, Qt.black)
+ self.appliEficas.noeudColore.updateNodeLabel
+
+ def updateNodeLabelInBlue(self):
+ # -------------------------------
+ if hasattr(self.appliEficas, "noeudColore"):
+ self.appliEficas.noeudColore.setForeground(0, Qt.black)
+ self.setForeground(0, Qt.blue)
+ labeltext, fonte, couleur = self.item.getLabelText()
+ if self.item.nom != tr(self.item.nom):
+ labeltext = str(tr(self.item.nom) + " :")
+ self.setText(0, labeltext)
+ self.appliEficas.noeudColore = self
+
+ def updatePlusieursNodeLabelInBlue(self, liste):
+ # ----------------------------------------------
+ if hasattr(self.appliEficas, "listeNoeudsColores"):
+ for noeud in self.appliEficas.listeNoeudsColores:
+ noeud.setTextColor(0, Qt.black)
+ noeud.updateNodeLabel()
+ self.appliEficas.listeNoeudsColores = []
+ for noeud in liste:
+ noeud.setTextColor(0, Qt.blue)
+ labeltext, fonte, couleur = noeud.item.getLabelText()
+ if item.nom != tr(item.nom):
+ labeltext = str(tr(item.nom) + " :")
+ noeud.setText(0, labeltext)
+ self.appliEficas.listeNoeudsColores.append(noeud)
+
+ def updateNodeTexteInBlack(self):
+ # --------------------------------
+ """Met a jour les noms des SD et valeurs des mots-cles"""
+ self.setTextColor(1, Qt.black)
+ value = tr(str(self.item.getText()))
+ self.setText(1, value)
+
+ def updateNodeTexte(self):
+ # ----------------------------
+ """Met a jour les noms des SD et valeurs des mots-cles"""
+ value = tr(str(self.item.getText()))
+ self.setText(1, value)
+
+ def updateNodeTexteInBlue(self):
+ # --------------------------------
+ self.setTextColor(1, Qt.blue)
+ value = tr(str(self.item.getText()))
+ self.setText(1, value)
+
+ def updateNodes(self):
+ # --------------------------------
+ # print 'NODE updateNodes', self.item.getLabelText()
+ self.buildChildren()
+
+ def updateValid(self):
+ # ----------------------
+ """Cette methode a pour but de mettre a jour la validite du noeud
+ et de propager la demande de mise a jour a son parent
+ """
+ # print "NODE updateValid", self.item.getLabelText()
+ self.updateNodeValid()
+ try:
+ self.treeParent.updateValid()
+ except:
+ pass
+
+ def updateTexte(self):
+ # ----------------------
+ """Met a jour les noms des SD et valeurs des mots-cles"""
+ # print "NODE updateTexte", self.item.getLabelText()
+ self.updateNodeTexte()
+ if self.isExpanded():
+ for child in self.children:
+ if child.isHidden() == false:
+ child.updateTexte()
+
+ def forceRecalculChildren(self, niveau):
+ # --------------------------------------
+ if self.state == "recalcule":
+ self.state = ""
+ return
+ self.state = "recalcule"
+ if hasattr(self.item, "object"):
+ self.item.object.state = "modified"
+ for child in self.children:
+ if niveau > 0:
+ child.forceRecalculChildren(niveau - 1)
+
+ def doPaste(self, node_selected, pos="after"):
+ # --------------------------------------------
+ """
+ Declenche la copie de l'objet item avec pour cible
+ l'objet passe en argument : node_selected
+ """
+ objet_a_copier = self.item.getCopieObjet()
+ child = node_selected.doPasteCommande(objet_a_copier, pos)
+ if self.editor.fenetreCentraleAffichee:
+ self.editor.fenetreCentraleAffichee.node.affichePanneau()
+ self.updateNodeLabelInBlack()
+ return child
+
+ def doPasteCommande(self, objet_a_copier, pos="after"):
+ # -----------------------------------------------------
+ """
+ Realise la copie de l'objet passe en argument qui est necessairement
+ un onjet
+ """
+ child = None
+ try:
+ # if 1 :
+ child = self.appendBrother(objet_a_copier, pos)
+ except:
+ pass
+ return child
+
+ def doPastePremier(self, objet_a_copier):
+ # ---------------------------------------
+ """
+ Realise la copie de l'objet passe en argument (objet_a_copier)
+ """
+ objet = objet_a_copier.item.getCopieObjet()
+ child = self.appendChild(objet, pos="first")
+ return child
+
+ def plieToutEtReafficheSaufItem(self, itemADeplier):
+ # ---------------------------------------------------
+ self.inhibeExpand = True
+ from InterfaceGUI.QT5 import compojdc
+
+ if isinstance(self, compojdc.Node):
+ self.affichePanneau()
+ self.inhibeExpand = False
+ return
+ self.editor.deplier = False
+ for item in self.children:
+ # il ne faut pas plier les blocs
+ from InterfaceGUI.QT5 import compobloc
+
+ if isinstance(item, compobloc.Node):
+ continue
+ item.setPlie()
+ if item == itemADeplier:
+ itemADeplier.setDeplie()
+ self.affichePanneau()
+ self.inhibeExpand = False
+
+ def plieToutEtReaffiche(self):
+ # -----------------------------
+ # print ('plieToutEtReaffiche', self.item.getNom())
+ from InterfaceGUI.QT5 import compojdc
+
+ if isinstance(self, compojdc.Node):
+ self.affichePanneau()
+ return
+ self.inhibeExpand = True
+ self.editor.deplier = False
+ for item in self.children:
+ # il ne faut pas plier les blocs
+ from InterfaceGUI.QT5 import compobloc
+
+ if isinstance(item, compobloc.Node):
+ continue
+ item.setPlie()
+ self.affichePanneau()
+ # print ("fin plieToutEtReaffiche", self.item.getNom())
+
+ def deplieToutEtReaffiche(self):
+ # -----------------------------
+ self.editor.deplier = True
+ for item in self.children:
+ item.setDeplie()
+ self.affichePanneau()
+
+ def setPlie(self):
+ # -----------------
+ # print "je mets inhibeExpand a true dans setPlie"
+ # print ("je suis dans plieTout", self.item.getNom())
+ from . import compojdc
+
+ if self.fenetre == self.editor.fenetreCentraleAffichee and isinstance(
+ self.treeParent, compojdc.Node
+ ):
+ return
+ self.tree.inhibeExpand = True
+ self.tree.collapseItem(self)
+ self.setPlieChildren()
+ self.tree.inhibeExpand = False
+ # print "je mets inhibeExpand a false dans setPlie"
+
+ # on ne plie pas au niveau 1
+ # self.plie=False
+ # for item in self.children :
+ # item.appartientAUnNoeudPlie=False
+
+ def setPlieChildren(self):
+ # -----------------------------
+ self.plie = True
+ from InterfaceGUI.QT5 import composimp
+
+ if isinstance(self, composimp.Node):
+ return
+ for c in self.children:
+ c.setPlieChildren()
+ # print "dans setPlieChildren appartientAUnNoeudPlie=True ", c, c.item.getLabelText()[0]
+ c.appartientAUnNoeudPlie = True
+ c.plie = True
+ # print "dans setPlieChildren plie", c.item.nom
+ # 01/2018 PNPN : boucle sur MT __ La ligne suivante ne me semble pas necessaire
+ # if not (isinstance(c,composimp.Node)) :c.setExpanded(False)
+
+ # Pour les blocs et les motcles list
+ # on affiche un niveau de plus
+ from InterfaceGUI.QT5 import compobloc
+ from InterfaceGUI.QT5 import compomclist
+
+ if isinstance(self, compobloc.Node) or (
+ isinstance(self, compomclist.Node) and self.item.isMCList()
+ ):
+ niveauPere = self.treeParent
+ while isinstance(niveauPere, compobloc.Node) or (
+ isinstance(niveauPere, compomclist.Node) and niveauPere.item.isMCList()
+ ):
+ niveauPere = niveauPere.treeParent
+ for c in self.children:
+ c.appartientAUnNoeudPlie = niveauPere.appartientAUnNoeudPlie
+ # print ("dans setPlieChildren appartientAUnNoeudPlie=True ", c, c.item.getLabelText()[0], "mis a la valeur ", niveauPere.appartientAUnNoeudPlie)
+ c.setExpanded(False)
+
+ def setDeplie(self):
+ # -----------------------------
+ # print "dans setPlieChildren pour", self.item.nom
+ # print "je mets inhibeExpand a true dans setDeplie"
+ self.tree.inhibeExpand = True
+ self.plie = False
+ self.tree.expandItem(self)
+ self.setDeplieChildren()
+ self.tree.inhibeExpand = False
+ # print "je mets inhibeExpand a false dans setDePlie"
+
+ def setDeplieChildren(self):
+ # -----------------------------
+ # print "dans setDeplieChildren appartientAUnNoeudPlie=False ", self.item.getLabelText()
+ for c in self.children:
+ c.setDeplieChildren()
+ # print "dans setDeplieChildren ", c.item.nom
+ c.appartientAUnNoeudPlie = False
+ c.setExpanded(True)
+ c.plie = False
+
+ def selectAvant(self):
+ # -----------------------------
+ i = self.item.jdc.etapes.index(self.item.object)
+ try:
+ cherche = self.item.jdc.etapes[i - 1]
+ except:
+ cherche = self.item.jdc.etapes[-1]
+ node = None
+ for i in self.tree.racine.children:
+ if i.item.object == cherche:
+ node = i
+ break
+ if node:
+ node.affichePanneau()
+ node.select()
+
+ def selectApres(self):
+ # ---------------------
+ i = self.item.jdc.etapes.index(self.item.object)
+ try:
+ cherche = self.item.jdc.etapes[i + 1]
+ except:
+ cherche = self.item.jdc.etapes[0]
+ node = None
+ for i in self.tree.racine.children:
+ if i.item.object == cherche:
+ node = i
+ break
+ if node:
+ node.affichePanneau()
+ node.select()
diff --git a/InterfaceGUI/QT5/compobloc.py b/InterfaceGUI/QT5/compobloc.py
new file mode 100644
index 00000000..b3cc9313
--- /dev/null
+++ b/InterfaceGUI/QT5/compobloc.py
@@ -0,0 +1,58 @@
+# -*- 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 Editeur import Objecttreeitem
+
+from . import compofact
+from . import browser
+from . import typeNode
+
+
+class Node(browser.JDCNode, typeNode.PopUpMenuNodeMinimal):
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
+
+ def getPanelGroupe(self, parentQt, commande):
+ maDefinition = self.item.get_definition()
+ monObjet = self.item.object
+ monNom = self.item.nom
+ maCommande = commande
+ if hasattr(parentQt, "niveau"):
+ self.niveau = parentQt.niveau + 1
+ else:
+ self.niveau = 1
+ from .monWidgetBloc import MonWidgetBloc
+
+ widget = MonWidgetBloc(
+ self, self.editor, parentQt, maDefinition, monObjet, self.niveau, maCommande
+ )
+
+
+class BLOCTreeItem(compofact.FACTTreeItem):
+ itemNode = Node
+
+ def isCopiable(self):
+ return 0
+
+
+import Accas
+
+treeitem = BLOCTreeItem
+objet = Accas.MCBLOC
diff --git a/InterfaceGUI/QT5/compocomm.py b/InterfaceGUI/QT5/compocomm.py
new file mode 100644
index 00000000..635d176f
--- /dev/null
+++ b/InterfaceGUI/QT5/compocomm.py
@@ -0,0 +1,115 @@
+# -*- 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 Editeur import Objecttreeitem
+from . import browser
+from . import typeNode
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+
+
+class Node(browser.JDCNode, typeNode.PopUpMenuNodePartiel):
+ def getPanel(self):
+ """ """
+ from .monWidgetCommentaire import MonWidgetCommentaire
+
+ return MonWidgetCommentaire(self, self.editor, self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNodePartiel.createPopUpMenu(self)
+ from PyQt5.QtWidgets import QAction
+
+ self.Decommente = QAction(tr("decommenter"), self.tree)
+ self.Decommente.triggered.connect(self.decommenter)
+ self.Decommente.setStatusTip(tr("Decommente la commande "))
+
+ if hasattr(self.item, "unComment"):
+ self.menu.addAction(self.Decommente)
+
+ def decommenter(self):
+ item = self.tree.currentItem()
+ item.unCommentIt()
+
+ def updateNodeLabel(self):
+ """ """
+ debComm = self.item.getText()
+ self.setText(1, tr(debComm))
+
+
+class COMMTreeItem(Objecttreeitem.ObjectTreeItem):
+ itemNode = Node
+
+ def init(self):
+ self.setFunction = self.setValeur
+
+ def getIconName(self):
+ """
+ Retourne le nom de l'icone associee au noeud qui porte self,
+ dependant de la validite de l'objet
+ NB : un commentaire est toujours valide ...
+ """
+ return "ast-white-percent"
+
+ 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
+ """
+ return tr("Commentaire"), None, None
+
+ def getValeur(self):
+ """
+ Retourne la valeur de l'objet Commentaire cad son texte
+ """
+ return self.object.getValeur() or ""
+
+ def getText(self):
+ texte = self.object.valeur
+ texte = texte.split("\n")[0]
+ if len(texte) < 25:
+ return texte
+ else:
+ return texte[0:24]
+
+ def setValeur(self, valeur):
+ """
+ Affecte valeur a l'objet COMMENTAIRE
+ """
+ self.object.setValeur(valeur)
+
+ def getSubList(self):
+ """
+ Retourne la liste des fils de self
+ """
+ return []
+
+ def getObjetCommentarise(self):
+ """
+ La methode getObjetCommentarise() de la classe compocomm.COMMTreeItem
+ 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 Extensions
+
+treeitem = COMMTreeItem
+objet = Extensions.commentaire.COMMENTAIRE
diff --git a/InterfaceGUI/QT5/compocommandecomm.py b/InterfaceGUI/QT5/compocommandecomm.py
new file mode 100644
index 00000000..88f9338b
--- /dev/null
+++ b/InterfaceGUI/QT5/compocommandecomm.py
@@ -0,0 +1,97 @@
+# -*- 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 traceback
+
+from Editeur import Objecttreeitem
+from Extensions.eficas_exception import EficasException
+from . import compocomm
+
+
+class COMMANDE_COMMTreeItem(Objecttreeitem.ObjectTreeItem):
+ itemNode = compocomm.Node
+
+ def init(self):
+ self.setFunction = self.setValeur
+
+ def getIconName(self):
+ """
+ Retourne le nom de l'icone associee au noeud qui porte self,
+ dependant de la validite de l'objet
+ NB : une commande commentarisee est toujours valide ...
+ """
+ if self.isValid():
+ return "ast-green-percent"
+ else:
+ return "ast-red-percent"
+
+ 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
+ """
+ return "commentaire"
+
+ def getValeur(self):
+ """
+ Retourne la valeur de la commande commentarisee cad son texte
+ """
+ return self.object.getValeur() or ""
+
+ def getText(self):
+ texte = self.object.valeur
+ texte = texte.split("\n")[0]
+ if len(texte) < 25:
+ return texte
+ else:
+ return texte[0:24]
+
+ def setValeur(self, valeur):
+ """
+ Afefcte valeur a l'objet commande commentarisee
+ """
+ self.object.setValeur(valeur)
+
+ def getSubList(self):
+ """
+ Retourne la liste des fils de self
+ """
+ return []
+
+ def unComment(self):
+ """
+ Demande a l'objet commande commentarisee de se decommentariser.
+ Si l'operation s'effectue correctement, retourne l'objet commande
+ et eventuellement le nom de la sd produite, sinon leve une exception
+ """
+ try:
+ commande, nom = self.object.unComment()
+ # self.parent.children[pos].select()
+ except Exception as e:
+ traceback.print_exc()
+ raise EficasException(e)
+ return commande, nom
+
+
+import Accas
+
+treeitem = COMMANDE_COMMTreeItem
+objet = Accas.COMMANDE_COMM
diff --git a/InterfaceGUI/QT5/compofact.py b/InterfaceGUI/QT5/compofact.py
new file mode 100644
index 00000000..9a475095
--- /dev/null
+++ b/InterfaceGUI/QT5/compofact.py
@@ -0,0 +1,187 @@
+# -*- 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 InterfaceGUI.QT5 import browser
+from InterfaceGUI.QT5 import typeNode
+from Extensions.i18n import tr
+
+from Editeur import Objecttreeitem
+import traceback
+
+
+class Node(browser.JDCNode, typeNode.PopUpMenuNodePartiel):
+ def getPanelGroupe(self, parentQt, commande):
+ # ----------------------------------------
+ maDefinition = self.item.get_definition()
+ monObjet = self.item.object
+ monNom = self.item.nom
+ maCommande = commande
+ if hasattr(parentQt, "niveau"):
+ self.niveau = parentQt.niveau + 1
+ else:
+ self.niveau = 1
+ if hasattr(self, "plie") and self.plie == True:
+ from InterfaceGUI.QT5.monWidgetFactPlie import MonWidgetFactPlie
+
+ widget = MonWidgetFactPlie(
+ self,
+ self.editor,
+ parentQt,
+ maDefinition,
+ monObjet,
+ self.niveau,
+ maCommande,
+ )
+ elif self.editor.maConfiguration.afficheFirstPlies and self.firstAffiche:
+ self.firstAffiche = False
+ self.setPlie()
+ from InterfaceGUI.QT5.monWidgetFactPlie import MonWidgetFactPlie
+
+ widget = MonWidgetFactPlie(
+ self,
+ self.editor,
+ parentQt,
+ maDefinition,
+ monObjet,
+ self.niveau,
+ maCommande,
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetFact import MonWidgetFact
+
+ widget = MonWidgetFact(
+ self,
+ self.editor,
+ parentQt,
+ maDefinition,
+ monObjet,
+ self.niveau,
+ maCommande,
+ )
+ return widget
+
+ def createPopUpMenu(self):
+ # ------------------------
+ typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
+
+
+class FACTTreeItem(Objecttreeitem.ObjectTreeItem):
+ itemNode = Node
+
+ def isExpandable(self):
+ # ----------------------
+ return 1
+
+ def getText(self):
+ # ----------------
+ return ""
+
+ def getLabelText(self):
+ # ----------------------
+ """Retourne 3 valeurs :
+ - le texte à afficher dans le noeud representant l'item
+ - la fonte dans laquelle afficher ce texte
+ - la couleur du texte
+ """
+ # None --> fonte et couleur par defaut
+ if not (hasattr(self.object, "getLabelText")):
+ return self.object.nom, None, None
+ return self.object.getLabelText(), None, None
+
+ def isValid(self):
+ # ----------------
+ return self.object.isValid()
+
+ def isCopiable(self):
+ # ----------------
+ return 1
+
+ def getIconName(self):
+ # ----------------
+ if self.object.isValid():
+ return "ast-green-los"
+ elif self.object.isOblig():
+ return "ast-red-los"
+ else:
+ return "ast-yel-los"
+
+ # PNPN ????
+ # def keys(self):
+ # keys=self.object.mc_dict
+ # return keys
+
+ def getSubList(self):
+ # ----------------
+ """
+ Reactualise la liste des items fils stockes dans self.sublist
+ """
+ liste = self.object.mcListe
+ sublist = [None] * len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj = item.getObject()
+ if old_obj in liste:
+ pos = liste.index(old_obj)
+ sublist[pos] = item
+ else:
+ pass # objets supprimes ignores
+ # ajout des items lies aux nouveaux objets
+ pos = 0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ def setFunction(value, object=obj):
+ object.setval(value)
+
+ item = self.makeObjecttreeitem(
+ self.appliEficas, obj.nom + " : ", obj, setFunction
+ )
+ sublist[pos] = item
+ pos = pos + 1
+
+ self.sublist = sublist
+ return self.sublist
+
+ def addItem(self, name, pos):
+ objet = self.object.addEntite(name, pos)
+ return objet
+
+ def suppItem(self, item):
+ """
+ Cette methode a pour fonction de supprimer l'item passee en argument
+ des fils de l'item FACT qui est son pere
+ - item = item du MOCLE a supprimer du MOCLE pere
+ - item.getObject() = MCSIMP ou MCBLOC
+ """
+ itemobject = item.getObject()
+ if itemobject.isOblig():
+ return (0, tr("Impossible de supprimer un mot-cle obligatoire "))
+
+ if self.object.suppEntite(itemobject):
+ message = tr("Mot-cle %s supprime") + itemobject.nom
+ return (1, message)
+ else:
+ return (0, tr("Pb interne : impossible de supprimer ce mot-cle"))
+
+
+import Accas
+
+objet = Accas.MCFACT
+treeitem = FACTTreeItem
diff --git a/InterfaceGUI/QT5/compoformule.py b/InterfaceGUI/QT5/compoformule.py
new file mode 100644
index 00000000..f14e78b8
--- /dev/null
+++ b/InterfaceGUI/QT5/compoformule.py
@@ -0,0 +1,198 @@
+# -*- 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
+#
+
+"""
+Ce module contient les classes permettant de definir les objets graphiques
+representant un objet de type FORMULE, cad le panneau et l'item de l'arbre
+d'EFICAS
+"""
+
+from . import compooper
+from . import browser
+from . import typeNode
+
+
+class FormuleNode(browser.JDCNode, typeNode.PopUpMenuNode):
+ def getPanel(self):
+ from .monWidgetFormule import MonWidgetFormule
+
+ return MonWidgetFormule(self, self.editor, self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNode.createPopUpMenu(self)
+
+
+class FORMULETreeItem(compooper.EtapeTreeItem):
+ """
+ Classe servant a definir l'item porte par le noeud de l'arbre d'EFICAS
+ qui represente la FORMULE
+ """
+
+ itemNode = FormuleNode
+
+ def init(self):
+ self.setFunction = self.setValeur
+
+ # ---------------------------------------------------------------------------
+ # API de FORMULE pour l'arbre
+ # ---------------------------------------------------------------------------
+ def getSubList(self):
+ """
+ Retourne la liste des fils de self
+ On considere que FORMULE n'a pas de fils
+ --> modification par rapport a MACRO classique
+ """
+ # dans EFICAS on ne souhaite pas afficher les mots-cles fils de FORMULE
+ # de facon traditionnelle
+ return []
+
+ def getIconName(self):
+ """
+ Retourne le nom de l'icone a afficher dans l'arbre
+ Ce nom depend de la validite de l'objet
+ """
+ if self.object.isActif():
+ if self.object.isValid():
+ return "ast-green-square"
+ else:
+ return "ast-red-square"
+ else:
+ return "ast-white-text"
+
+ 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
+ """
+ return self.labeltext, None, None
+ # if self.object.isActif():
+ # None --> fonte et couleur par defaut
+ # return tr(self.labeltext),None,None
+ # else:
+ # return tr(self.labeltext),None,None
+ # return self.labeltext,fontes.standard_italique,None
+
+ # ---------------------------------------------------------------------------
+ # Methodes permettant la modification et la lecture des attributs
+ # du parametre = API graphique de la FORMULE pour Panel et EFICAS
+ # ---------------------------------------------------------------------------
+
+ def getNom(self):
+ """
+ Retourne le nom de la FORMULE
+ """
+ return self.object.getNom()
+
+ def getType(self):
+ """
+ Retourne le type de la valeur retournee par la FORMULE
+ """
+ return self.object.type_retourne
+
+ def getArgs(self):
+ """
+ Retourne les arguments de la FORMULE
+ """
+ args = ""
+ for mot in self.object.mcListe:
+ if mot.nom == "NOM_PARA":
+ args = mot.valeur
+ break
+ if args:
+ if args[0] == "(" and args[-1] == ")":
+ args = args[1:-1]
+ # transforme en tuple si ce n est pas deja le casa
+ try:
+ args = args.split(",")
+ except:
+ pass
+ return args
+
+ def getCorps(self):
+ """
+ Retourne le corps de la FORMULE
+ """
+ corps = ""
+ for mot in self.object.mcListe:
+ if mot.nom == "VALE":
+ corps = mot.valeur
+ break
+ return corps
+
+ def getListeTypesAutorises(self):
+ """
+ Retourne la liste des types autorises pour les valeurs de sortie
+ d'une FORMULE
+ """
+ return self.object.l_types_autorises
+
+ def saveFormule(self, new_nom, new_typ, new_arg, new_exp):
+ """
+ Verifie si (new_nom,new_typ,new_arg,new_exp) definit bien une FORMULE
+ licite :
+ - si oui, stocke ces parametres comme nouveaux parametres de la
+ FORMULE courante et retourne 1
+ - si non, laisse les parametres anciens de la FORMULE inchanges et
+ retourne 0
+ """
+ test, erreur = self.object.verifFormule_python(
+ formule=(new_nom, new_typ, new_arg, new_exp)
+ )
+ if test:
+ # la formule est bien correcte : on sauve les nouveaux parametres
+ test = self.object.updateFormulePython(
+ formule=(new_nom, new_typ, new_exp, new_arg)
+ )
+ return test, erreur
+
+ # ---------------------------------------------------------------------------
+ # Acces aux methodes de verification de l'objet FORM_ETAPE
+ # ---------------------------------------------------------------------------
+
+ def verifNom(self, nom):
+ """
+ Lance la verification du nom passe en argument
+ """
+ return self.object.verifNom(nom)
+
+ def verifArguments(self, arguments):
+ """
+ Lance la verification des arguments passes en argument
+ """
+ return self.object.verifArguments("(" + arguments + ")")
+
+ def verifFormule(self, formule):
+ """
+ Lance la verification de FORMULE passee en argument
+ """
+ return self.object.verifFormule(formule=formule)
+
+ def verifFormule_python(self, formule):
+ """
+ Lance la verification de FORMULE passee en argument
+ """
+ return self.object.verifFormule_python(formule=formule)
+
+
+import Accas
+
+treeitem = FORMULETreeItem
+objet = Accas.FORM_ETAPE
diff --git a/InterfaceGUI/QT5/compojdc.py b/InterfaceGUI/QT5/compojdc.py
new file mode 100644
index 00000000..2d16f1a8
--- /dev/null
+++ b/InterfaceGUI/QT5/compojdc.py
@@ -0,0 +1,133 @@
+# -*- 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 Editeur import Objecttreeitem
+from . import browser
+from . import typeNode
+from Extensions.i18n import tr
+
+
+class Node(browser.JDCNode, typeNode.PopUpMenuRacine):
+ def getPanel(self):
+ from .monChoixCommande import MonChoixCommande
+ return MonChoixCommande(self, self.item, self.editor)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuRacine.createPopUpMenu(self)
+
+ def addParameters(self, apres):
+ param = self.appendChild("PARAMETRE", pos=0)
+ return param
+
+
+class JDCTreeItem(Objecttreeitem.ObjectTreeItem):
+ itemNode = Node
+
+ def isExpandable(self):
+ return 1
+
+ def getText(self):
+ return " "
+
+ def getLabelText(self):
+ # None --> fonte et couleur par defaut
+ return tr(self.object.nom), None, None
+
+ def getJdc(self):
+ """
+ Retourne l'objet pointe par self
+ """
+ return self.object
+
+ def getIconName(self):
+ if self.object.isValid():
+ return "ast-green-square"
+ else:
+ return "ast-red-square"
+
+ # def keys(self):
+ # if self.object.etapes_niveaux != []:
+ # return range(len(self.object.etapes_niveaux))
+ # else:
+ # return range(len(self.object.etapes))
+
+ def addItem(self, name, pos):
+ cmd = self._object.addEntite(name, pos)
+ return cmd
+
+ def suppItem(self, item):
+ # item = item de l'ETAPE a supprimer du JDC
+ # item.getObject() = ETAPE ou COMMENTAIRE
+ # self.object = JDC
+
+ itemobject = item.getObject()
+ if self.object.suppEntite(itemobject):
+ if itemobject.nature == "COMMENTAIRE":
+ message = tr("Commentaire supprime")
+ else:
+ message = tr("Commande %s supprimee", itemobject.nom)
+ return 1, message
+ else:
+ message = tr("Pb interne : impossible de supprimer cet objet")
+ return 0, message
+
+ def getSubList(self):
+ """
+ Retourne la liste des items fils de l'item jdc.
+ Cette liste est conservee et mise a jour a chaque appel
+ """
+ if self.object.etapes_niveaux != []:
+ liste = self.object.etapes_niveaux
+ else:
+ liste = self.object.etapes
+ sublist = [None] * len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj = item.getObject()
+ if old_obj in liste:
+ pos = liste.index(old_obj)
+ sublist[pos] = item
+ else:
+ pass # objets supprimes ignores
+ # ajout des items lies aux nouveaux objets
+ pos = 0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ item = self.makeObjecttreeitem(self.appliEficas, obj.nom + " : ", obj)
+ sublist[pos] = item
+ pos = pos + 1
+
+ self.sublist = sublist
+ return self.sublist
+
+ def getLNomsEtapes(self):
+ """Retourne la liste des noms des etapes de self.object"""
+ return self.object.getLNomsEtapes()
+
+ def getListeCmd(self):
+ listeCmd = self.object.niveau.definition.getListeCmd()
+ return listeCmd
+
+
+import Accas
+
+treeitem = JDCTreeItem
+objet = Accas.JDC
diff --git a/InterfaceGUI/QT5/compomacro.py b/InterfaceGUI/QT5/compomacro.py
new file mode 100644
index 00000000..5a4e8b3d
--- /dev/null
+++ b/InterfaceGUI/QT5/compomacro.py
@@ -0,0 +1,200 @@
+# -*- 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
+#
+
+# Modules Python
+
+import os, sys
+import types
+import traceback
+
+# Modules Eficas
+from Editeur import Objecttreeitem
+from Extensions.i18n import tr
+from InterfaceGUI.QT5 import compooper
+from InterfaceGUI.QT5 import browser
+from InterfaceGUI.QT5 import typeNode
+
+
+class MACRONode(browser.JDCNode, typeNode.PopUpMenuNode):
+ def getPanel(self):
+ from .monWidgetCommande import MonWidgetCommande
+
+ return MonWidgetCommande(self, self.editor, self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNode.createPopUpMenu(self)
+
+
+# def view3D(self) :
+# from Editeur import TroisDPal
+# troisD=TroisDPal.TroisDPilote(self.item,self.editor.appliEficas)
+# troisD.envoievisu()
+
+
+class MACROTreeItem(compooper.EtapeTreeItem):
+ # """ Cette classe herite d'une grande partie des comportements
+ # de la classe compooper.EtapeTreeItem
+ # """
+ itemNode = MACRONode
+
+
+# ------------------------------------
+# Classes necessaires a INCLUDE
+# ------------------------------------
+
+
+class INCLUDETreeItemBase(MACROTreeItem):
+ def __init__(self, appliEficas, labeltext, object, setFunction):
+ MACROTreeItem.__init__(self, appliEficas, labeltext, object, setFunction)
+
+ def isCopiable(self):
+ return 0
+
+
+class INCLUDENode(browser.JDCNode, typeNode.PopUpMenuNode):
+ def getPanel(self):
+ from .monWidgetCommande import MonWidgetCommande
+
+ return MonWidgetCommande(self, self.editor, self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNode.createPopUpMenu(self)
+
+ def makeEdit(self): # ,appliEficas,node
+ if self.item.object.text_converted == 0:
+ # Le texte du fichier inclus n'a pas pu etre converti par le module convert
+ msg = tr(
+ "Le fichier de commande n'a pas pu etre converti pour etre editable par Eficas\n\n"
+ )
+ msg = msg + self.item.object.text_error
+ return
+
+ if not hasattr(self.item.object, "jdc_aux") or self.item.object.jdc_aux is None:
+ # L'include n'est pas initialise
+ self.item.object.buildInclude(None, "")
+
+ # On cree un nouvel onglet dans le bureau
+ self.editor.vm.displayJDC(
+ self.item.object.jdc_aux, self.item.object.jdc_aux.nom
+ )
+
+
+class INCLUDETreeItem(INCLUDETreeItemBase):
+ itemNode = INCLUDENode
+
+
+# ------------------------------------
+# Classes necessaires a POURSUITE
+# ------------------------------------
+
+
+class POURSUITENode(browser.JDCNode, typeNode.PopUpMenuNode):
+ def getPanel(self):
+ from .monWidgetCommande import MonWidgetCommande
+
+ return MonWidgetCommande(self, self.editor, self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNode.createPopUpMenu(self)
+
+ def makeEdit(self): # ,appliEficas,node
+ if self.item.object.text_converted == 0:
+ msg = tr(
+ "Le fichier de commande n'a pas pu etre converti pour etre editable par Eficas\n\n"
+ )
+ msg = msg + self.item.object.text_error
+ return
+
+ if not hasattr(self.item.object, "jdc_aux") or self.item.object.jdc_aux is None:
+ text = """DEBUT()
+ FIN()"""
+ self.object.buildPoursuite(None, text)
+
+ # On cree un nouvel onglet dans le bureau
+ self.editor.vm.displayJDC(
+ self.item.object.jdc_aux, self.item.object.jdc_aux.nom
+ )
+
+
+class POURSUITETreeItem(INCLUDETreeItemBase):
+ itemNode = POURSUITENode
+
+
+# ----------------------------------------
+# Classes necessaires a INCLUDE MATERIAU
+# ----------------------------------------
+
+
+class MATERIAUNode(MACRONode):
+ def getPanel(self):
+ from .monWidgetCommande import MonWidgetCommande
+
+ return MonWidgetCommande(self, self.editor, self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNode.createPopUpMenu(self)
+
+ def makeView(self):
+ if (
+ hasattr(self.item.object, "fichier_ini")
+ and self.item.object.fichier_ini == None
+ ):
+ QMessageBox.information(
+ self,
+ tr("Include vide"),
+ tr("L'include doit etre correctement initialise pour etre visualise"),
+ )
+ return
+ f = open(self.item.object.fichier_ini, "rb")
+ texte = f.read()
+ f.close()
+ from desVisu import DVisu
+
+ monVisuDialg = DVisu(parent=self.editor.appliEficas, fl=0)
+ monVisuDialg.TB.setText(texte)
+ monVisuDialg.show()
+
+
+class INCLUDE_MATERIAUTreeItem(INCLUDETreeItemBase):
+ itemNode = MATERIAUNode
+
+
+# ------------------------------------
+# TreeItem
+# ------------------------------------
+
+
+def treeitem(appliEficas, labeltext, object, setFunction=None):
+ """Factory qui retourne l'item adapte au type de macro :
+ INCLUDE, POURSUITE, MACRO
+ """
+ if object.nom == "INCLUDE_MATERIAU":
+ return INCLUDE_MATERIAUTreeItem(appliEficas, labeltext, object, setFunction)
+ elif object.nom == "INCLUDE" or object.nom == "DICTDATA":
+ return INCLUDETreeItem(appliEficas, labeltext, object, setFunction)
+ elif object.nom == "POURSUITE":
+ return POURSUITETreeItem(appliEficas, labeltext, object, setFunction)
+ else:
+ return MACROTreeItem(appliEficas, labeltext, object, setFunction)
+
+
+import Accas
+
+objet = Accas.MACRO_ETAPE
diff --git a/InterfaceGUI/QT5/compomclist.py b/InterfaceGUI/QT5/compomclist.py
new file mode 100644
index 00000000..fb80c100
--- /dev/null
+++ b/InterfaceGUI/QT5/compomclist.py
@@ -0,0 +1,260 @@
+# -*- 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 types
+import traceback
+
+from . import compofact
+from . import browser
+from . import typeNode
+from Extensions.i18n import tr
+
+from Editeur import Objecttreeitem
+from Noyau.N_OBJECT import ErrorObj
+
+
+class Node(browser.JDCNode, typeNode.PopUpMenuNodeMinimal):
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
+
+ def getPanelGroupe(self, parentQt, commande):
+ maDefinition = self.item.get_definition()
+ monObjet = self.item.object
+ monNom = self.item.nom
+ maCommande = commande
+ if hasattr(parentQt, "niveau"):
+ self.niveau = parentQt.niveau + 1
+ else:
+ self.niveau = 1
+ # attention si l objet est une mclist on utilise bloc
+ if not (monObjet.isMCList()):
+ if hasattr(self, "plie") and self.plie == True:
+ from InterfaceGUI.QT5.monWidgetFactPlie import MonWidgetFactPlie
+
+ widget = MonWidgetFactPlie(
+ self,
+ self.editor,
+ parentQt,
+ maDefinition,
+ monObjet,
+ self.niveau,
+ maCommande,
+ )
+ elif self.editor.maConfiguration.afficheFirstPlies and self.firstAffiche:
+ self.firstAffiche = False
+ self.setPlie()
+ from InterfaceGUI.QT5.monWidgetFactPlie import MonWidgetFactPlie
+
+ widget = MonWidgetFactPlie(
+ self,
+ self.editor,
+ parentQt,
+ maDefinition,
+ monObjet,
+ self.niveau,
+ maCommande,
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetFact import MonWidgetFact
+
+ widget = MonWidgetFact(
+ self,
+ self.editor,
+ parentQt,
+ maDefinition,
+ monObjet,
+ self.niveau,
+ maCommande,
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetBloc import MonWidgetBloc
+
+ widget = MonWidgetBloc(
+ self,
+ self.editor,
+ parentQt,
+ maDefinition,
+ monObjet,
+ self.niveau,
+ maCommande,
+ )
+ return widget
+
+ def doPaste(self, node_selected, pos):
+ objet_a_copier = self.item.getCopieObjet()
+ # before est un effet de bord heureux sur l index
+ child = self.appendBrother(objet_a_copier, "before")
+ if self.editor.fenetreCentraleAffichee:
+ self.editor.fenetreCentraleAffichee.node.affichePanneau()
+ self.update_NodeLabelInBlack()
+ self.parent().buildChildren()
+ return child
+
+
+class MCListTreeItem(Objecttreeitem.SequenceTreeItem, compofact.FACTTreeItem):
+ """La classe MCListTreeItem joue le role d'un adaptateur pour les objets
+ du noyau Accas instances de la classe MCLIST.
+ Elle adapte ces objets pour leur permettre d'etre integres en tant que
+ noeuds dans un arbre graphique (voir treewidget.py et ObjectTreeItem.py).
+ Cette classe delegue les appels de methode et les acces
+ aux attributs a l'objet du noyau soit manuellement soit
+ automatiquement (voir classe Delegate et attribut object).
+ """
+
+ itemNode = Node
+
+ def init(self):
+ # Si l'objet Accas (MCList) a moins d'un mot cle facteur
+ # on utilise directement ce mot cle facteur comme delegue
+ self.updateDelegate()
+
+ def updateDelegate(self):
+ if len(self._object) > 1:
+ self.setDelegate(self._object)
+ else:
+ self.setDelegate(self._object.data[0])
+
+ def panel(self, jdcdisplay, pane, node):
+ """Retourne une instance de l'objet panneau associe a l'item (self)
+ Si la liste ne contient qu'un mot cle facteur, on utilise le panneau
+ FACTPanel.
+ Si la liste est plus longue on utilise le panneau MCLISTPanel.
+ """
+ if len(self._object) > 1:
+ return MCLISTPanel(jdcdisplay, pane, node)
+ elif isinstance(self._object.data[0], ErrorObj):
+ return compoerror.ERRORPanel(jdcdisplay, pane, node)
+ else:
+ return compofact.FACTPanel(jdcdisplay, pane, node)
+
+ def isExpandable(self):
+ if len(self._object) > 1:
+ return Objecttreeitem.SequenceTreeItem.isExpandable(self)
+ else:
+ return compofact.FACTTreeItem.isExpandable(self)
+
+ def getSubList(self):
+ self.updateDelegate()
+ if len(self._object) <= 1:
+ self._object.data[0].alt_parent = self._object
+ return compofact.FACTTreeItem.getSubList(self)
+
+ liste = self._object.data
+ sublist = [None] * len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj = item.getObject()
+ if old_obj in liste:
+ pos = liste.index(old_obj)
+ sublist[pos] = item
+ else:
+ pass # objets supprimes ignores
+ # ajout des items lies aux nouveaux objets
+ pos = 0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ def setFunction(value, object=obj):
+ object = value
+
+ item = self.makeObjecttreeitem(
+ self.appliEficas, obj.nom + " : ", obj, setFunction
+ )
+ sublist[pos] = item
+ # Attention : on ajoute une information supplementaire pour l'actualisation de
+ # la validite. L'attribut parent d'un MCFACT pointe sur le parent de la MCLISTE
+ # et pas sur la MCLISTE elle meme ce qui rompt la chaine de remontee des
+ # informations de validite. alt_parent permet de remedier a ce defaut.
+ obj.alt_parent = self._object
+ pos = pos + 1
+
+ self.sublist = sublist
+ return self.sublist
+
+ 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 getDocu(self):
+ """Retourne la clef de doc de l'objet pointe par self"""
+ return self.object.getDocu()
+
+ def isCopiable(self):
+ if len(self._object) > 1:
+ return Objecttreeitem.SequenceTreeItem.isCopiable(self)
+ else:
+ return compofact.FACTTreeItem.isCopiable(self)
+
+ def isMCFact(self):
+ """
+ Retourne 1 si l'objet pointe par self est un MCFact, 0 sinon
+ """
+ return len(self._object) <= 1
+
+ def isMCList(self):
+ """
+ Retourne 1 si l'objet pointe par self est une MCList, 0 sinon
+ """
+ return len(self._object) > 1
+
+ def getCopieObjet(self):
+ return self._object.data[0].copy()
+
+ def addItem(self, obj, pos):
+ # print "compomclist.addItem",obj,pos
+ if len(self._object) <= 1:
+ return compofact.FACTTreeItem.addItem(self, obj, pos)
+
+ o = self.object.addEntite(obj, pos)
+ return o
+
+ def suppItem(self, item):
+ """
+ Retire un objet MCFACT de la MCList (self.object)
+ """
+ # print "compomclist.suppItem",item
+ obj = item.getObject()
+ if len(self._object) <= 1:
+ return compofact.FACTTreeItem.suppItem(self, item)
+
+ if self.object.suppEntite(obj):
+ if len(self._object) == 1:
+ self.updateDelegate()
+ message = "Mot-clef " + obj.nom + " supprime"
+ return (1, message)
+ else:
+ return (0, tr("Impossible de supprimer ce mot-clef"))
+
+
+import Accas
+
+objet = Accas.MCList
+
+
+def treeitem(appliEficas, labeltext, object, setFunction):
+ """Factory qui produit un objet treeitem adapte a un objet
+ Accas.MCList (attribut objet de ce module)
+ """
+ return MCListTreeItem(appliEficas, labeltext, object, setFunction)
diff --git a/InterfaceGUI/QT5/compooper.py b/InterfaceGUI/QT5/compooper.py
new file mode 100644
index 00000000..009cbf6a
--- /dev/null
+++ b/InterfaceGUI/QT5/compooper.py
@@ -0,0 +1,285 @@
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from builtins import str
+import os
+import tempfile
+
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+
+from Editeur import Objecttreeitem
+from . import browser
+from . import typeNode
+
+
+class Node(browser.JDCNode, typeNode.PopUpMenuNode):
+ def select(self):
+ browser.JDCNode.select(self)
+ self.treeParent.tree.openPersistentEditor(self, 1)
+ self.monWidgetNom = self.treeParent.tree.itemWidget(self, 1)
+ self.monWidgetNom.returnPressed.connect(self.nomme)
+ if self.item.getIconName() == "ast-red-square":
+ self.monWidgetNom.setDisabled(True)
+ # else : self.monWidgetNom.setFocus() ;self.monWidgetNom.setDisabled(False)
+
+ def nomme(self):
+ nom = str(self.monWidgetNom.text())
+ self.editor.initModif()
+ test, mess = self.item.nommeSd(nom)
+ if test == 0:
+ self.editor.afficheInfos(mess, "red")
+ old = self.item.getText()
+ self.monWidgetNom.setText(old)
+ else:
+ self.editor.afficheCommentaire(tr("Nommage du concept effectue"))
+ self.onValid()
+ try:
+ self.fenetre.LENom.setText(nom)
+ except:
+ pass
+
+ def getPanel(self):
+ from .monWidgetCommande import MonWidgetCommande
+
+ return MonWidgetCommande(self, self.editor, self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNode.createPopUpMenu(self)
+
+
+# def view3D(self) :
+# from Editeur import TroisDPal
+# troisD=TroisDPal.TroisDPilote(self.item,self.editor.appliEficas)
+# troisD.envoievisu()
+
+
+class EtapeTreeItem(Objecttreeitem.ObjectTreeItem):
+ """La classe EtapeTreeItem est un adaptateur des objets ETAPE du noyau
+ Accas. Elle leur permet d'etre affichés comme des noeuds
+ d'un arbre graphique.
+ Cette classe a entre autres deux attributs importants :
+ - _object qui est un pointeur vers l'objet du noyau
+ - object qui pointe vers l'objet auquel sont délégués les
+ appels de méthode et les acces aux attributs
+ Dans le cas d'une ETAPE, _object et object pointent vers le
+ meme objet.
+ """
+
+ itemNode = Node
+
+ def isExpandable(self):
+ return 1
+
+ def getIconName(self):
+ """
+ Retourne le nom de l'icone a afficher dans l'arbre
+ Ce nom depend de la validite de l'objet
+ """
+ if not self.object.isActif():
+ return "ast-white-square"
+ elif self.object.isValid():
+ return "ast-green-square"
+ else:
+ valid = self.validChild()
+ valid = valid * self.validRegles("non")
+ if self.reste_val != {}:
+ valid = 0
+ if valid == 0:
+ return "ast-red-square"
+ else:
+ try:
+ # on traite ici le cas d include materiau
+ # print self.object.definition.nom
+ if self.object.fichier_ini != self.object.nom_mater:
+ return "ast-red-square"
+ except:
+ pass
+ return "ast-yellow-square"
+
+ def getLabelText(self):
+ """Retourne 3 valeurs :
+ - le texte a afficher dans le noeud représentant l'item
+ - la fonte dans laquelle afficher ce texte
+ - la couleur du texte
+ """
+ return self.labeltext, None, None
+ # if self.object.isActif():
+ # None --> fonte et couleur par défaut
+ # return self.labeltext,None,None
+ # else:
+ # return self.labeltext, None, None #CS_pbruno todo
+
+ # def get_objet(self,name) :
+ # for v in self.object.mcListe:
+ # if v.nom == name : return v
+ # return None
+
+ # def getType_sd_prod(self):
+ # """
+ # Retourne le nom du type du concept résultat de l'étape
+ # """
+ # sd_prod=self.object.getType_produit()
+ # if sd_prod:
+ # return sd_prod.__name__
+ # else:
+ # return ""
+
+ def addItem(self, name, pos):
+ mcent = self._object.addEntite(name, pos)
+ return mcent
+
+ def suppItem(self, item):
+ # item : item du MOCLE de l'ETAPE a supprimer
+ # item.getObject() = MCSIMP, MCFACT, MCBLOC ou MCList
+ itemobject = item.getObject()
+ if itemobject.isOblig():
+ return (0, tr("Impossible de supprimer un mot-clef obligatoire "))
+ if self.object.suppEntite(itemobject):
+ message = tr("Mot-clef %s supprime ", itemobject.nom)
+ return (1, message)
+ else:
+ return (0, tr("Pb interne : impossible de supprimer ce mot-clef"))
+
+ def getText(self):
+ try:
+ return self.object.getSdname()
+ except:
+ return ""
+
+ # PNPN ????
+ # def keys(self):
+ # keys=self.object.mc_dict
+ # return keys
+
+ def getSubList(self):
+ """
+ Reactualise la liste des items fils stockes dans self.sublist
+ """
+ if self.isActif():
+ liste = self.object.mcListe
+ else:
+ liste = []
+
+ sublist = [None] * len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj = item.getObject()
+ if old_obj in liste:
+ pos = liste.index(old_obj)
+ sublist[pos] = item
+ else:
+ pass # objets supprimes ignores
+
+ # ajout des items lies aux nouveaux objets
+ pos = 0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ def setFunction(value, object=obj):
+ object.setval(value)
+
+ item = self.makeObjecttreeitem(
+ self.appliEficas, obj.nom + " : ", obj, setFunction
+ )
+ sublist[pos] = item
+ pos = pos + 1
+
+ self.sublist = sublist
+ return self.sublist
+
+ def isValid(self):
+ return self.object.isValid()
+
+ def isCopiable(self):
+ """
+ Retourne 1 si l'objet est copiable, 0 sinon
+ """
+ return 1
+
+ def updateDeplace(self, item):
+ if item.sd and item.sd.nom:
+ self.object.sd = item.sd
+ self.object.sd.nom = item.sd.nom
+
+ def update(self, item):
+ if item.sd and item.sd.nom:
+ self.nommeSd(item.sd.nom)
+
+ def nommeSd(self, nom):
+ """Lance la méthode de nommage de la SD"""
+ oldnom = ""
+ if self.object.sd != None:
+ oldnom = self.object.sd.nom
+ test, mess = self.object.nommeSd(nom)
+ if test:
+ self.object.parent.resetContext()
+ if test and oldnom in self.appliEficas.dict_reels:
+ self.appliEficas.dict_reels[nom] = self.appliEficas.dict_reels[oldnom]
+ return test, mess
+
+ def isReentrant(self):
+ return self.object.isReentrant()
+
+ def getNomsSdOperReentrant(self):
+ return self.object.getNomsSdOperReentrant()
+
+ def getObjetCommentarise(self):
+ """
+ Cette méthode retourne un objet commentarisé
+ représentatif de self.object
+ """
+ # Format de fichier utilisé
+ format = self.appliEficas.formatFichierIn
+ return self.object.getObjetCommentarise(format)
+
+ def getObjetCommentarise_BAK(self):
+ """
+ Cette méthode retourne un objet commentarisé
+ représentatif de self.object
+ """
+ import generator, Accas
+
+ # Format de fichier utilisé
+ format = self.appliEficas.format_fichier
+ g = generator.plugins[format]()
+ texte_commande = g.gener(self.object, format="beautifie")
+ # Il faut enlever la premiere ligne vide de texte_commande que
+ # rajoute le generator
+ rebut, texte_commande = texte_commande.split("\n", 1)
+ # on construit l'objet COMMANDE_COMM repésentatif de self mais non
+ # enregistré dans le jdc
+ commande_comment = Accas.COMMANDE_COMM(
+ texte=texte_commande, reg="non", parent=self.object.parent
+ )
+ commande_comment.niveau = self.object.niveau
+ commande_comment.jdc = commande_comment.parent = self.object.jdc
+
+ pos = self.object.parent.etapes.index(self.object)
+ parent = self.object.parent
+ self.object.parent.suppEntite(self.object)
+ parent.addEntite(commande_comment, pos)
+
+ return commande_comment
+
+
+import Accas
+
+treeitem = EtapeTreeItem
+objet = Accas.ETAPE
diff --git a/InterfaceGUI/QT5/compoparam.py b/InterfaceGUI/QT5/compoparam.py
new file mode 100644
index 00000000..39a3cb60
--- /dev/null
+++ b/InterfaceGUI/QT5/compoparam.py
@@ -0,0 +1,153 @@
+# -*- 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
+#
+"""
+ Ce module contient les classes permettant de definir les objets graphiques
+ representant un objet de type PARAMETRE, cad le panneau et l'item de l'arbre
+ d'EFICAS
+"""
+# import modules Python
+import types
+from Extensions.i18n import tr
+
+# import modules EFICAS
+from Editeur import Objecttreeitem
+from . import browser
+from . import typeNode
+
+
+class Node(browser.JDCNode, typeNode.PopUpMenuNodePartiel):
+ def getPanel(self):
+ """ """
+ from .monWidgetParam import MonWidgetParam
+
+ return MonWidgetParam(self, self.editor, self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNodePartiel.createPopUpMenu(self)
+ self.menu.removeAction(self.Documentation)
+
+ def doPaste(self, node_selected, pos="after"):
+ return None
+
+
+class PARAMTreeItem(Objecttreeitem.ObjectTreeItem):
+ """
+ Classe servant a definir l'item porte par le noeud de l'arbre d'EFICAS
+ qui represente le PARAMETRE
+ """
+
+ itemNode = Node
+
+ def init(self):
+ self.setFunction = self.setValeur
+
+ # ---------------------------------------------------------------------------
+ # API du PARAMETRE pour l'arbre
+ # ---------------------------------------------------------------------------
+
+ def getIconName(self):
+ """
+ Retourne le nom de l'icone associee au noeud qui porte self,
+ dependant de la validite de l'objet
+ NB : un PARAMETRE est toujours valide ...
+ """
+ if self.isActif():
+ if self.isValid():
+ return "ast-green-square"
+ else:
+ return "ast-red-square"
+ else:
+ return "ast-white-square"
+
+ 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
+ """
+ return tr("PARAMETRE"), None, None
+
+ def getText(self):
+ """
+ Retourne le texte a afficher apres le nom de la commande (ici apres 'parametre')
+ Ce texte est tronque a 25 caracteres
+ """
+ texte = self.object.nom + "=" + str(self.object.valeur)
+ if type(self.object.valeur) == list:
+ texte = self.nom + " = ["
+ for l in self.object.valeur:
+ texte = texte + str(l) + ","
+ texte = texte[0:-1] + "]"
+ texte = texte.split("\n")[0]
+ if len(texte) < 25:
+ return texte
+ else:
+ return texte[0:24] + "..."
+
+ def getSubList(self):
+ """
+ Retourne la liste des fils de self
+ """
+ return []
+
+ # ---------------------------------------------------------------------------
+ # Methodes permettant la modification et la lecture des attributs
+ # du parametre = API graphique du PARAMETRE pour Panel et EFICAS
+ # ---------------------------------------------------------------------------
+
+ def getValeur(self):
+ """
+ Retourne la valeur de l'objet PARAMETRE cad son texte
+ """
+ if self.object.valeur is None:
+ return ""
+ else:
+ return self.object.valeur
+
+ def getNom(self):
+ """
+ Retourne le nom du parametre
+ """
+ return self.object.nom
+
+ def setValeur(self, new_valeur):
+ """
+ Affecte valeur a l'objet PARAMETRE
+ """
+ self.object.setValeur(new_valeur)
+
+ def setNom(self, new_nom):
+ """
+ Renomme le parametre
+ """
+ self.object.setNom(new_nom)
+ # self.object.setAttribut('nom',new_nom)
+
+ def getFr(self):
+ """
+ Retourne le fr associe au parametre, cad la bulle d'aide pour EFICAS
+ """
+ return tr("Definition d'un parametre")
+
+
+import Extensions.parametre
+
+treeitem = PARAMTreeItem
+objet = Extensions.parametre.PARAMETRE
diff --git a/InterfaceGUI/QT5/compoproc.py b/InterfaceGUI/QT5/compoproc.py
new file mode 100644
index 00000000..2f590b68
--- /dev/null
+++ b/InterfaceGUI/QT5/compoproc.py
@@ -0,0 +1,45 @@
+# -*- 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 Editeur import Objecttreeitem
+from . import compooper
+from . import browser
+from . import typeNode
+
+
+class Node(browser.JDCNode, typeNode.PopUpMenuNode):
+ def getPanel(self):
+ # print "getPanel de compoproc"
+ from .monWidgetCommande import MonWidgetCommande
+
+ return MonWidgetCommande(self, self.editor, self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNode.createPopUpMenu(self)
+
+
+class ProcEtapeTreeItem(compooper.EtapeTreeItem):
+ itemNode = Node
+
+
+import Accas
+
+treeitem = ProcEtapeTreeItem
+objet = Accas.PROC_ETAPE
diff --git a/InterfaceGUI/QT5/composimp.py b/InterfaceGUI/QT5/composimp.py
new file mode 100644
index 00000000..51bea6bd
--- /dev/null
+++ b/InterfaceGUI/QT5/composimp.py
@@ -0,0 +1,1023 @@
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# Modules Python
+import types, os
+
+from copy import copy, deepcopy
+import traceback
+from InterfaceGUI.QT5 import typeNode
+
+# Modules Eficas
+from Editeur import Objecttreeitem
+from InterfaceGUI.QT5 import browser
+from Noyau.N_CR import justifyText
+from Accas import SalomeEntry
+from Accas import ASSD
+from Accas import UserASSD
+from Accas import UserASSDMultiple
+
+
+class Node(browser.JDCNode, typeNode.PopUpMenuNodeMinimal):
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
+
+ def getPanelGroupe(self, parentQt, maCommande):
+ # print (self,self.item.nom, )
+ maDefinition = self.item.get_definition()
+ monObjet = self.item.object
+ monNom = self.item.nom
+
+ # le mot clef est cache ou cache avec defaut
+ if maDefinition.statut in ("c", "d"):
+ return None
+ # label informatif
+ if monObjet.isInformation():
+ from InterfaceGUI.QT5.monWidgetInfo import MonWidgetInfo
+
+ widget = MonWidgetInfo(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ self.widget = widget
+ return widget
+
+ # Attention l ordre des if est important
+ # Attention il faut gerer les blocs et les facteurs
+ # a gerer comme dans composimp
+ # Gestion des matrices
+ if self.item.waitMatrice():
+ from InterfaceGUI.QT5.monWidgetMatrice import MonWidgetMatrice
+
+ widget = MonWidgetMatrice(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ self.widget = widget
+ return widget
+
+ # print "____________________________", monNom, self.item.waitCo()
+ # print "____________________________", monNom, self.item.waitAssd()
+ # Gestion d'une seule valeur (eventuellement un tuple ou un complexe)
+ if maDefinition.into != [] and maDefinition.into != None:
+ if type(maDefinition.into) == types.FunctionType:
+ monInto = maDefinition.into()
+ else:
+ monInto = maDefinition.into
+
+ if maDefinition.max == 1:
+ # A verifier
+ if maDefinition.intoSug != [] and maDefinition.intoSug != None:
+ from InterfaceGUI.QT5.monWidgetCBIntoSug import MonWidgetCBIntoSug
+
+ widget = MonWidgetCBIntoSug(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ elif maDefinition.into != [] and maDefinition.into != None:
+ if maDefinition.fenetreIhm == "menuDeroulant":
+ from InterfaceGUI.QT5.monWidgetCB import MonWidgetCB
+
+ widget = MonWidgetCB(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ elif len(monInto) < 4:
+ from InterfaceGUI.QT5.monWidgetRadioButton import MonWidgetRadioButton
+
+ widget = MonWidgetRadioButton(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ elif len(monInto) < 7:
+ from InterfaceGUI.QT5.monWidget4a6RadioButton import (
+ MonWidget4a6RadioButton,
+ )
+
+ widget = MonWidget4a6RadioButton(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetCB import MonWidgetCB
+
+ widget = MonWidgetCB(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+
+ elif self.item.waitBool():
+ from InterfaceGUI.QT5.monWidgetSimpBool import MonWidgetSimpBool
+
+ widget = MonWidgetSimpBool(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ elif self.item.waitFichier():
+ from InterfaceGUI.QT5.monWidgetSimpFichier import MonWidgetSimpFichier
+
+ widget = MonWidgetSimpFichier(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+
+ # PNPNPN - a faire
+ elif self.item.waitDate():
+ from InterfaceGUI.QT5.monWidgetDate import MonWidgetDate
+
+ widget = MonWidgetDate(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ elif self.item.waitHeure():
+ from InterfaceGUI.QT5.monWidgetHeure import MonWidgetHeure
+
+ widget = MonWidgetHeure(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+
+ elif self.item.waitTuple():
+ num = self.item.object.definition.type[0].ntuple
+ nomDeLaClasse = "MonWidgetSimpTuple" + str(num)
+ nomDuFichier = "InterfaceGUI.QT5.monWidgetSimpTupleN"
+ try:
+ # if 1 :
+ _temp = __import__(
+ nomDuFichier, globals(), locals(), [nomDeLaClasse], 0
+ )
+ # print (_temp)
+ MonWidgetSimpTuple = getattr(_temp, nomDeLaClasse)
+ # print (MonWidgetSimpTuple)
+ except:
+ print("Pas de Tuple de longueur : ", num)
+ # print ("Prevenir la maintenance ")
+ widget = MonWidgetSimpTuple(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+
+ elif self.item.waitComplex():
+ from InterfaceGUI.QT5.monWidgetSimpComplexe import MonWidgetSimpComplexe
+
+ widget = MonWidgetSimpComplexe(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+
+ elif self.item.waitCo():
+ if len(self.item.getSdAvantDuBonType()) == 0:
+ from InterfaceGUI.QT5.monWidgetUniqueSDCO import MonWidgetUniqueSDCO
+
+ widget = MonWidgetUniqueSDCO(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetSDCOInto import MonWidgetSDCOInto
+
+ widget = MonWidgetSDCOInto(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ elif self.item.waitAssd():
+ # PN - pour ne pas appeller trop souvent self.item.getSdAvantDuBonType()
+ if not (self.item.waitUserAssdOrAssdMultipleEnCreation()):
+ maListe = self.item.getSdAvantDuBonType()
+ if self.item.waitUserAssdOrAssdMultipleEnCreation():
+ from InterfaceGUI.QT5.monWidgetCreeUserAssd import MonWidgetCreeUserAssd
+
+ widget = MonWidgetCreeUserAssd(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ # elif len(self.item.getSdAvantDuBonType()) == 0 :
+ elif len(maListe) == 0:
+ from InterfaceGUI.QT5.monWidgetVide import MonWidgetVide
+
+ widget = MonWidgetVide(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ # elif len(self.item.getSdAvantDuBonType()) < 4 :
+ elif len(maListe) < 4:
+ from InterfaceGUI.QT5.monWidgetRadioButton import MonWidgetRadioButtonSD
+
+ widget = MonWidgetRadioButtonSD(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ # elif len(self.item.getSdAvantDuBonType()) < 7 :
+ elif len(maListe) < 7:
+ from InterfaceGUI.QT5.monWidget4a6RadioButton import (
+ MonWidget4a6RadioButtonSD,
+ )
+
+ widget = MonWidget4a6RadioButtonSD(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetCB import MonWidgetCBSD
+
+ widget = MonWidgetCBSD(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+
+ elif self.item.waitSalome() and self.editor.salome:
+ from InterfaceGUI.QT5.monWidgetSimpSalome import MonWidgetSimpSalome
+
+ widget = MonWidgetSimpSalome(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+
+ elif self.item.waitTxm():
+ from InterfaceGUI.QT5.monWidgetSimpTxt import MonWidgetSimpTxt
+
+ widget = MonWidgetSimpTxt(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetSimpBase import MonWidgetSimpBase
+
+ widget = MonWidgetSimpBase(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+
+ # Gestion des listes
+ else:
+ if maDefinition.intoSug != [] and maDefinition.intoSug != None:
+ if self.item in self.editor.listeDesListesOuvertes or not (
+ self.editor.afficheListesPliees
+ ):
+ from InterfaceGUI.QT5.monWidgetIntoSug import MonWidgetIntoSug
+
+ widget = MonWidgetIntoSug(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetPlusieursPlie import (
+ MonWidgetPlusieursPlie,
+ )
+
+ widget = MonWidgetPlusieursPlie(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ # if maDefinition.into != [] and maDefinition.into != None:
+ # Attention pas fini --> on attend une liste de ASSD avec ordre
+ elif self.item.waitAssd() and self.item.isListSansOrdreNiDoublon():
+ listeAAfficher = self.item.getSdAvantDuBonType()
+ if len(listeAAfficher) == 0:
+ from InterfaceGUI.QT5.monWidgetVide import MonWidgetVide
+
+ widget = MonWidgetVide(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetPlusieursInto import (
+ MonWidgetPlusieursInto,
+ )
+
+ widget = MonWidgetPlusieursInto(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ elif (
+ self.item.waitAssd()
+ and not self.item.waitUserAssdOrAssdMultipleEnCreation()
+ ):
+ listeAAfficher = self.item.getSdAvantDuBonType()
+ # a changer selon UserASSD ou UserASSDMultiple
+ mctype = maDefinition.type[0]
+ enable_salome_selection = self.editor.salome and (
+ ("grma" in repr(mctype))
+ or ("grno" in repr(mctype))
+ or ("SalomeEntry" in repr(mctype))
+ or (
+ hasattr(mctype, "enable_salome_selection")
+ and mctype.enable_salome_selection
+ )
+ )
+ if enable_salome_selection:
+ from InterfaceGUI.QT5.monWidgetPlusieursBase import (
+ MonWidgetPlusieursBase,
+ )
+
+ widget = MonWidgetPlusieursBase(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ elif len(listeAAfficher) == 0:
+ from InterfaceGUI.QT5.monWidgetVide import MonWidgetVide
+
+ widget = MonWidgetVide(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ elif self.item in self.editor.listeDesListesOuvertes or not (
+ self.editor.afficheListesPliees
+ ):
+ from InterfaceGUI.QT5.monWidgetPlusieursASSDIntoOrdonne import (
+ MonWidgetPlusieursASSDIntoOrdonne,
+ )
+
+ widget = MonWidgetPlusieursASSDIntoOrdonne(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetPlusieursPlie import (
+ MonWidgetPlusieursPlieASSD,
+ )
+
+ widget = MonWidgetPlusieursPlieASSD(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ elif self.item.waitTuple():
+ if self.item.object.definition.fenetreIhm == "Tableau":
+ from InterfaceGUI.QT5.monWidgetTableau import MonWidgetTableau
+
+ widget = MonWidgetTableau(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ num = self.item.object.definition.type[0].ntuple
+ nomDeLaClasse = "MonWidgetPlusieursTuple" + str(num)
+ nomDuFichier = "InterfaceGUI.QT5.monWidgetPlusieursTupleN"
+ try:
+ _temp = __import__(
+ nomDuFichier, globals(), locals(), [nomDeLaClasse], 0
+ )
+ MonWidgetPlusieursTuple = getattr(_temp, nomDeLaClasse)
+ except:
+ print("Pas de Tuple de longueur : ", num)
+ print("Prevenir la maintenance ")
+ widget = MonWidgetPlusieursTuple(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+
+ elif self.item.hasInto():
+ if self.item.isListSansOrdreNiDoublon():
+ if self.item in self.editor.listeDesListesOuvertes or not (
+ self.editor.afficheListesPliees
+ ):
+ from InterfaceGUI.QT5.monWidgetPlusieursInto import (
+ MonWidgetPlusieursInto,
+ )
+
+ widget = MonWidgetPlusieursInto(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetPlusieursPlie import (
+ MonWidgetPlusieursPlie,
+ )
+
+ widget = MonWidgetPlusieursPlie(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ if self.item in self.editor.listeDesListesOuvertes or not (
+ self.editor.afficheListesPliees
+ ):
+ from InterfaceGUI.QT5.monWidgetPlusieursIntoOrdonne import (
+ MonWidgetPlusieursIntoOrdonne,
+ )
+
+ widget = MonWidgetPlusieursIntoOrdonne(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetPlusieursPlie import (
+ MonWidgetPlusieursPlie,
+ )
+
+ widget = MonWidgetPlusieursPlie(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ if self.item.waitUserAssdOrAssdMultipleEnCreation():
+ from InterfaceGUI.QT5.monWidgetPlusieursCreeUserAssd import (
+ MonWidgetPlusieursCreeUserAssd,
+ )
+
+ widget = MonWidgetPlusieursCreeUserAssd(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ elif self.item in self.editor.listeDesListesOuvertes or not (
+ self.editor.afficheListesPliees
+ ):
+ from InterfaceGUI.QT5.monWidgetPlusieursBase import (
+ MonWidgetPlusieursBase,
+ )
+
+ widget = MonWidgetPlusieursBase(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+ else:
+ from InterfaceGUI.QT5.monWidgetPlusieursPlie import (
+ MonWidgetPlusieursPlie,
+ )
+
+ widget = MonWidgetPlusieursPlie(
+ self, maDefinition, monNom, monObjet, parentQt, maCommande
+ )
+
+ self.widget = widget
+ return widget
+
+
+class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
+ itemNode = Node
+
+ def init(self):
+ self.expandable = 0
+
+ # -----------------------------------------------
+ #
+ # Methodes liees aux informations sur le Panel
+ # ou au mot-clef simple
+ #
+ # -----------------------------------------------
+ # isList
+ # hasInto
+ # getMinMax
+ # getMultiplicite
+ # getIntervalle
+ # getListeValeurs
+ # getListePossible
+
+ def isList(self):
+ """
+ Cette methode indique si le mot cle simple attend une liste (valeur de retour 1)
+ ou s'il n'en attend pas (valeur de retour 0)
+
+ Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
+ Dans le cas sans validateur, l'information est donnee par l'attribut max
+ de la definition du mot cle.
+ Dans le cas avec validateur, il faut combiner l'information precedente avec
+ celle issue de l'appel de la methode isList sur le validateur.On utilisera
+ l'operateur ET pour effectuer cette combinaison (AndVal).
+ """
+ is_a_list = 0
+ min, max = self.getMinMax()
+ assert min <= max
+ if max > 1:
+ is_a_list = 1
+ # Dans le cas avec validateurs, pour que le mot cle soit considere
+ # comme acceptant une liste, il faut que max soit superieur a 1
+ # ET que la methode isList du validateur retourne 1. Dans les autres cas
+ # on retournera 0 (n'attend pas de liste)
+ if self.definition.validators:
+ is_a_list = self.definition.validators.isList() * is_a_list
+ return is_a_list
+
+ def isListSansOrdreNiDoublon(self):
+ if self.definition.homo == "SansOrdreNiDoublon":
+ return 1
+ return 0
+
+ def hasInto(self):
+ """
+ Cette methode indique si le mot cle simple propose un choix (valeur de retour 1)
+ ou s'il n'en propose pas (valeur de retour 0)
+
+ Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
+ Dans le cas sans validateur, l'information est donnee par l'attribut into
+ de la definition du mot cle.
+ Dans le cas avec validateurs, pour que le mot cle soit considere
+ comme proposant un choix, il faut que into soit present OU
+ que la methode hasInto du validateur retourne 1. Dans les autres cas
+ on retournera 0 (ne propose pas de choix)
+ """
+ has_an_into = 0
+ if self.definition.into:
+ has_an_into = 1
+ elif self.definition.validators:
+ has_an_into = self.definition.validators.hasInto()
+ return has_an_into
+
+ def hasIntoSug(self):
+ if self.definition.intoSug:
+ return 1
+ return 0
+
+ def getMinMax(self):
+ """Retourne les valeurs min et max de la definition de object"""
+ return self.object.getMinMax()
+
+ def getMultiplicite(self):
+ """A preciser.
+ Retourne la multiplicite des valeurs affectees a l'objet
+ represente par l'item. Pour le moment retourne invariablement 1.
+ """
+ return 1
+
+ def getIntervalle(self):
+ """
+ Retourne le domaine de valeur attendu par l'objet represente
+ par l'item.
+ """
+ return self.object.getintervalle()
+
+ def getListeValeurs(self):
+ """Retourne la liste des valeurs de object"""
+ valeurs = self.object.getListeValeurs()
+ try:
+ if "R" in self.object.definition.type:
+ clef = self.object.getNomConcept()
+ if clef in self.appliEficas.dict_reels:
+ if type(valeurs) == tuple:
+ valeurs_reelles = []
+ for val in valeurs:
+ if val in self.appliEficas.dict_reels[clef]:
+ valeurs_reelles.append(
+ self.appliEficas.dict_reels[clef][val]
+ )
+ else:
+ valeurs_reelles.append(val)
+ else:
+ if valeurs in self.appliEficas.dict_reels[clef]:
+ valeurs_reelles = self.appliEficas.dict_reels[clef][valeurs]
+ valeurs = valeurs_reelles
+ except:
+ pass
+ return valeurs
+
+ def getListePossible(self, listeActuelle=[]):
+ if hasattr(self.definition.validators, "into"):
+ valeurspossibles = self.definition.validators.into
+ else:
+ valeurspossibles = self.get_definition().into
+
+ if listeActuelle == []:
+ return valeurspossibles
+
+ # On ne garde que les items valides
+ listevalideitem = []
+ if type(valeurspossibles) in (list, tuple):
+ pass
+ else:
+ valeurspossibles = (valeurspossibles,)
+ for item in valeurspossibles:
+ encorevalide = self.valideItem(item)
+ if encorevalide:
+ listevalideitem.append(item)
+
+ # on ne garde que les choix possibles qui passent le test de valideListePartielle
+ listevalideliste = []
+ for item in listevalideitem:
+ encorevalide = self.valideListePartielle(item, listeActuelle)
+ if encorevalide:
+ listevalideliste.append(item)
+ # print listevalideliste
+ return listevalideliste
+
+ def getListePossibleAvecSug(self, listeActuelle=[]):
+ if hasattr(self.definition, "intoSug"):
+ valeurspossibles = self.definition.intoSug
+ else:
+ return listeActuelle
+
+ if listeActuelle == []:
+ return valeurspossibles
+ valeurspossibles = valeurspossibles + listeActuelle
+
+ # On ne garde que les items valides
+ listevalideitem = []
+ if type(valeurspossibles) in (list, tuple):
+ pass
+ else:
+ valeurspossibles = (valeurspossibles,)
+ for item in valeurspossibles:
+ encorevalide = self.valideItem(item)
+ if encorevalide:
+ listevalideitem.append(item)
+
+ # on ne garde que les choix possibles qui passent le test de valideListePartielle
+ listevalideliste = []
+ for item in listevalideitem:
+ encorevalide = self.valideListePartielle(item, listeActuelle)
+ if encorevalide:
+ listevalideliste.append(item)
+ return listevalideliste
+
+ def getListeParamPossible(self):
+ liste_param = []
+ l1, l2 = self.jdc.getParametresFonctionsAvantEtape(self.getEtape())
+ for param in self.object.jdc.params:
+ if param.nom not in l1:
+ continue
+ encorevalide = self.valideItem(param.valeur)
+ if encorevalide:
+ type_param = param.valeur.__class__.__name__
+ for typ in self.definition.type:
+ if typ == "R":
+ liste_param.append(param)
+ if typ == "I" and type_param == "int":
+ liste_param.append(param)
+ if typ == "TXM" and type_param == "str":
+ liste_param.append(repr(param))
+ if ("grma" in repr(typ)) and type_param == "str":
+ liste_param.append(param.nom)
+ return liste_param
+
+ # --------------------------------------------------
+ #
+ # Methodes liees a la validite des valeurs saisies
+ #
+ # ---------------------------------------------------
+ # valideItem
+ # valideListePartielle
+ # valideListeComplete
+ # infoErreurItem
+ # infoErreurListe
+ # isInIntervalle
+ # isValid
+
+ def valideItem(self, item):
+ """
+ La validation est realisee directement par l'objet
+ """
+ return self.object.valideItem(item)
+
+ def valideListePartielle(self, item, listecourante):
+ # On protege la liste en entree en la copiant
+ valeur = list(listecourante)
+ if item:
+ valeur.append(item)
+ return self.object.validValeurPartielle(valeur)
+
+ def valideListeComplete(self, valeur):
+ return self.object.validValeur(valeur)
+
+ def infoErreurItem(self):
+ commentaire = ""
+ if self.definition.validators:
+ commentaire = self.definition.validators.infoErreurItem()
+ return commentaire
+
+ def aide(self):
+ commentaire = ""
+ if self.definition.validators:
+ commentaire = self.definition.validators.aide()
+ return commentaire
+
+ def infoErreurListe(self):
+ commentaire = ""
+ if self.definition.validators:
+ commentaire = self.definition.validators.infoErreurListe()
+ return commentaire
+
+ def isInIntervalle(self, valeur):
+ """
+ Retourne 1 si la valeur est dans l'intervalle permis par
+ l'objet represente par l'item.
+ """
+ return self.valideItem(valeur)
+
+ def isValid(self):
+ valide = self.object.isValid()
+ return valide
+
+ # --------------------------------------------------
+ #
+ # Autres ...
+ #
+ # ---------------------------------------------------
+ # getIconName
+ # getText
+ # setValeurCo
+ # getSdAvantDuBonType
+
+ def getIconName(self):
+ if self.appliEficas.maConfiguration.differencieSiDefaut and self.isValid():
+ if self.object.definition.defaut != None:
+ if self.object.valeur == self.object.definition.defaut:
+ return "ast-green-dark-ball"
+ if self.object.definition.max > 1 and list(self.object.valeur) == list(
+ self.object.definition.defaut
+ ):
+ return "ast-green-dark-ball"
+ return "ast-green-ball"
+ elif self.isValid():
+ return "ast-green-ball"
+ elif self.object.isOblig():
+ return "ast-red-ball"
+ else:
+ return "ast-yel-ball"
+
+ def getText(self):
+ """
+ Classe SIMPTreeItem
+ Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
+ pointe par self
+ """
+ if (
+ self.waitUserAssdMultiple()
+ or self.object.waitUserAssd()
+ or self.object.waitAssd()
+ ):
+ return self.object.valeur
+ # if self.object.valeur != None : return self.object.valeur.nom
+ # else : return ""
+ text = self.object.getText()
+ if text == None:
+ text = ""
+ return text
+
+ def setValeurCo(self, nomCo):
+ """
+ Affecte au MCS pointe par self l'objet de type CO et de nom nom_co
+ """
+ ret = self.object.setValeurCo(nomCo)
+ # print "setValeurCo",ret
+ return ret
+
+ def getSdAvantDuBonType(self):
+ """
+ Retourne la liste des noms des SD presentes avant l'etape qui contient
+ le MCS pointe par self et du type requis par ce MCS
+ """
+ # A changer pour tenir compte des UserASSDMultiple
+ # ici on passe par parent pour avoir le bon type
+ # if self.waitUserAssdMultiple() :
+ # l=self.object.parent.getSdCreeParObjetAvecFiltre(self.object)
+ # return l
+ if self.waitUserAssdMultiple():
+ l = self.object.getUserAssdPossible()
+ return l
+ a = self.object.etape.parent.getSdAvantDuBonType(
+ self.object.etape, self.object.definition.type
+ )
+ if self.waitUserAssd():
+ l = self.jdc.getSdCreeParObjet(self.object.definition.type)
+ else:
+ l = []
+ return a + l
+
+ def getSdAvantDuBonTypePourTypeDeBase(self):
+ a = self.object.jdc.getSdAvantDuBonTypePourTypeDe_Base(
+ self.object.etape, "LASSD"
+ )
+ return a
+
+ def deleteValeurCo(self, valeur=None):
+ """
+ Supprime la valeur du mot cle (de type CO)
+ il faut propager la destruction aux autres etapes
+ """
+ if not valeur:
+ valeur = self.object.valeur
+ # XXX faut il vraiment appeler delSdprod ???
+ # self.object.etape.parent.delSdprod(valeur)
+ self.object.etape.parent.deleteConcept(valeur)
+
+ # -----------------------------------------------
+ #
+ # Methodes liees au type de l objet attendu
+ #
+ # -----------------------------------------------
+ # waitCo
+ # waitGeom
+ # waitComplex
+ # waitReel
+ # waitAssd
+ # getType
+
+ def waitCo(self):
+ """
+ Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un objet de type ASSD qui n'existe pas encore (type CO()),
+ 0 sinon
+ """
+ return self.object.waitCo()
+
+ def waitFichier(self):
+ maDefinition = self.object.definition
+ try:
+ if ("Repertoire" in maDefinition.type[0]) or (
+ "Fichier" in maDefinition.type[0]
+ ):
+ return 1
+ except:
+ return 0
+
+ def waitGeom(self):
+ """
+ Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un objet GEOM, 0 sinon
+ """
+ return self.object.waitGeom()
+
+ def waitTxm(self):
+ return self.object.waitTxm()
+
+ def waitComplex(self):
+ """Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un complexe, 0 sinon"""
+ if "C" in self.object.definition.type:
+ return 1
+ else:
+ return 0
+
+ def waitReel(self):
+ """Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un reel, 0 sinon"""
+ if "R" in self.object.definition.type:
+ return 1
+ else:
+ return 0
+
+ def waitTuple(self):
+ return self.object.waitTuple()
+
+ def waitDate(self):
+ """Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un reel, 0 sinon"""
+ if "DateHHMMAAAA" in self.object.definition.type:
+ return 1
+ else:
+ return 0
+
+ def waitHeure(self):
+ """Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un reel, 0 sinon"""
+ if "HeureHHMMSS" in self.object.definition.type:
+ return 1
+ else:
+ return 0
+
+ def waitTuple(self):
+ """Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un Tuple, 0 sinon"""
+ for ss_type in self.object.definition.type:
+ if repr(ss_type).find("Tuple") != -1:
+ return 1
+ return 0
+
+ def waitMatrice(self):
+ """Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un Tuple, 0 sinon"""
+ # il faut trouver autre chose que ce find!!!
+ for ss_type in self.object.definition.type:
+ # if repr(ss_type).find('Matrice') != -1 :
+ if hasattr(ss_type, "typElt"):
+ return 1
+ return 0
+
+ def waitAssd(self):
+ """Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un objet de type ASSD ou derive, 0 sinon"""
+ return self.object.waitAssd()
+
+ def waitAssdOrTypeBase(self):
+ boo = 0
+ if len(self.object.definition.type) > 1:
+ if self.waitReel():
+ boo = 1
+ if "I" in self.object.definition.type:
+ boo = 1
+ return boo
+
+ def waitSalome(self):
+ monType = self.object.definition.type[0]
+ if "grma" in repr(monType):
+ return True
+ if "grno" in repr(monType):
+ return True
+ try:
+ if issubclass(monType, SalomeEntry):
+ return True
+ except:
+ pass
+ return False
+
+ def getType(self):
+ """
+ Retourne le type de valeur attendu par l'objet represente par l'item.
+ """
+ return self.object.getType()
+
+ # -----------------------------------------------------
+ #
+ # Methodes liees a l evaluation de la valeur saisie
+ #
+ # -----------------------------------------------------
+ # evalValeur
+ # evalValeurItem
+ # isCO
+ # traiteReel
+
+ def evalValeur(self, valeur):
+ """Lance l'interpretation de 'valeur' (chaine de caracteres) comme valeur de self :
+ - retourne l'objet associe si on a pu interpreter (entier, reel, ASSD,...)
+ - retourne 'valeur' (chaine de caracteres) sinon
+ """
+ newvaleur = self.evalVal(valeur)
+ return newvaleur, 1
+
+ def evalValeurItem(self, valeur):
+ """Lance l'interpretation de 'valeur' qui doit ne pas etre un tuple
+ - va retourner la valeur de retour et la validite
+ selon le type de l objet attendu
+ - traite les reels et les parametres
+ """
+ # print "evalValeurItem",valeur
+ if valeur == None or valeur == "":
+ return None, 0
+ validite = 1
+ if self.waitReel():
+ valeurinter = self.traiteReel(valeur)
+ if valeurinter != None:
+ valeurretour, validite = self.object.evalValeur(valeurinter)
+ else:
+ valeurretour, validite = self.object.evalValeur(valeur)
+ elif self.waitGeom():
+ valeurretour, validite = valeur, 1
+ else:
+ valeurretour, validite = self.object.evalValeur(valeur)
+
+ if validite == 0:
+ if (type(valeur) == bytes or type(valeur) == str) and self.object.waitTxm():
+ essai_valeur = "'" + valeur + "'"
+ valeurretour, validite = self.object.evalValeur(essai_valeur)
+
+ if hasattr(valeurretour, "__class__"):
+ # if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
+ if valeurretour.__class__.__name__ in ("PARAMETRE",):
+ validite = 1
+
+ # if self.waitCo():
+ # CCAR : il ne faut pas essayer de creer un concept
+ # il faut simplement en chercher un existant ce qui a du etre fait par self.object.evalValeur(valeur)
+ # try:
+ # valeurretour=Accas.CO(valeur)
+ # except:
+ # valeurretour=None
+ # validite=0
+ # on est dans le cas ou on a evalue et ou on n'aurait pas du
+ if self.object.waitTxm():
+ if type(valeurretour) != bytes:
+ valeurretour = str(valeur)
+ validite = 1
+ return valeurretour, validite
+
+ def isCO(self, valeur=None):
+ """
+ Indique si valeur est un concept produit de la macro
+ Cette methode n'a de sens que pour un MCSIMP d'une MACRO
+ Si valeur vaut None on teste la valeur du mot cle
+ """
+ # Pour savoir si un concept est un nouveau concept de macro
+ # on regarde s'il est present dans l'attribut sdprods de l'etape
+ # ou si son nom de classe est CO.
+ # Il faut faire les 2 tests car une macro non valide peut etre
+ # dans un etat pas tres catholique avec des CO pas encore types
+ # et donc pas dans sdprods (resultat d'une exception dans typeSDProd)
+ if not valeur:
+ valeur = self.object.valeur
+ if valeur in self.object.etape.sdprods:
+ return 1
+ # if type(valeur) is not types.InstanceType:return 0
+ if type(valeur) is not object:
+ return 0
+ if valeur.__class__.__name__ == "CO":
+ return 1
+ return 0
+
+ def isParam(self, valeur):
+ for param in self.jdc.params:
+ if repr(param) == valeur:
+ return 1
+ return 0
+
+ def traiteReel(self, valeur):
+ """
+ Cette fonction a pour but de rajouter le '.' en fin de chaine pour un reel
+ ou de detecter si on fait reference a un concept produit par DEFI_VALEUR
+ ou un EVAL ...
+ """
+ valeur = valeur.strip()
+ liste_reels = self.getSdAvantDuBonType()
+ if valeur in liste_reels:
+ return valeur
+ if len(valeur) >= 3:
+ if valeur[0:4] == "EVAL":
+ # on a trouve un EVAL --> on retourne directement la valeur
+ return valeur
+ if valeur.find(".") == -1:
+ # aucun '.' n'a ete trouve dans valeur --> on en rajoute un a la fin
+ if self.isParam(valeur):
+ return valeur
+ else:
+ if valeur.find("e") != -1:
+ # Notation scientifique ?
+ try:
+ r = eval(valeur)
+ return valeur
+ except:
+ return None
+ else:
+ return valeur + "."
+ else:
+ return valeur
+
+
+import Accas
+
+treeitem = SIMPTreeItem
+objet = Accas.MCSIMP
diff --git a/InterfaceGUI/QT5/configuration.py b/InterfaceGUI/QT5/configuration.py
new file mode 100644
index 00000000..ea74f310
--- /dev/null
+++ b/InterfaceGUI/QT5/configuration.py
@@ -0,0 +1,272 @@
+# -*- 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
+#
+"""
+ Ce module sert pour charger les parametres de configuration d'EFICAS
+"""
+import os, sys, types, re
+import traceback
+from Extensions.i18n import tr
+
+
+class configBase(object):
+ # -------------------------------
+ def __init__(self, appliEficas, repIni):
+ # -------------------------------
+
+ # Classe de base permettant de lire, afficher
+ # et sauvegarder les fichiers utilisateurs
+ # On a deux directories : la directory generale (Repertoire d install + Nom du code
+ # Par exemple : ~/Install_Eficas/EficasV1_14/Openturns_Wrapper
+ # et la directorie de l utilisateur
+ # HOME/.Eficas_Openturns
+ # Le fichier prefs.py va etre lu dans la directory generale
+ # puis surcharge eventuellement par celui contenu dans ${PREFS_CATA_$CODE}
+ # par celui de l utilisateur
+ # le fichier de catalogue va etre lu dans la directory de l utilisateur s il exite
+ # dans le fichier general sinon
+
+ self.appliEficas = appliEficas
+ self.code = appliEficas.code
+ self.salome = appliEficas.salome
+ if self.salome:
+ self.name = "editeur_salome.ini"
+ else:
+ self.name = "editeur.ini"
+ self.rep_mat = None
+ self.repIni = repIni
+
+ if self.code == None:
+ self.code = ""
+ self.rep_user = os.path.join(
+ os.path.expanduser("~"), ".config/Eficas", self.code
+ )
+ # else :
+ # self.rep_user = os.path.join('C:/','.config/Eficas',self.code)
+
+ self.setValeursParDefaut()
+
+ if self.code != "":
+ self.lectureFichierIniStandard()
+ self.lectureFichierIniIntegrateur()
+ self.lectureFichierIniUtilisateur()
+
+ if self.boutonDsMenuBar:
+ self.closeAutreCommande = True
+ self.closeFrameRechercheCommande = True
+
+ # Particularite des schemas MAP
+ if hasattr(self, "make_ssCode"):
+ self.make_ssCode(self.ssCode)
+
+ if not os.path.isdir(self.savedir):
+ self.savedir = os.path.join(
+ os.path.expanduser("~"), ".config/Eficas", self.code
+ )
+
+ def setValeursParDefaut(self):
+ # -----------------------------
+
+ # Valeurs par defaut
+ if not os.path.isdir(self.rep_user):
+ os.makedirs(self.rep_user)
+ self.path_doc = os.path.abspath(os.path.join(self.repIni, "..", "Doc"))
+ self.exec_acrobat = "acroread"
+ nomDir = "Eficas_" + self.code
+ self.savedir = os.path.abspath(os.path.join(os.path.expanduser("~"), nomDir))
+ # if sys.platform[0:5]=="linux" :
+ # self.savedir = os.path.abspath(os.path.join(os.environ['HOME'],nomDir))
+ # else:
+ # self.savedir = os.path.abspath('C:/')
+ self.modeNouvCommande = "initial"
+ self.affiche = "alpha"
+ self.closeAutreCommande = False
+ self.closeFrameRechercheCommande = False
+ self.closeFrameRechercheCommandeSurPageDesCommandes = False
+ self.closeEntete = False
+ self.closeArbre = False
+ self.demandeLangue = False
+ self.suiteTelemac = False
+ self.nombreDeBoutonParLigne = 0
+ self.translatorFichier = None
+ self.dicoImages = {}
+ self.dicoIcones = {}
+ self.afficheCommandesPliees = True
+ self.afficheFirstPlies = False
+ self.simpleClic = False
+ self.afficheOptionnelVide = False
+ self.afficheListesPliees = True
+ self.boutonDsMenuBar = False
+ self.ficIcones = None
+ self.repIcones = None
+ self.differencieSiDefaut = False
+ self.typeDeCata = "Python"
+ self.closeParenthese = False
+ self.closeOptionnel = False
+ self.afficheFactOptionnel = False
+ self.enleverActionStructures = False
+ self.enleverPoubellePourCommande = False
+ self.enleverParametres = False
+ self.enleverSupprimer = False
+ self.ajoutExecution = False
+ self.utilParExtensions = []
+ self.rendVisiblesLesCaches = False
+ self.pasDeMCOptionnels = False
+
+ self.dumpXSD = False
+ self.withXSD = False
+ self.afficheIhm = True
+
+ # self.afficheUQ=False
+ self.afficheUQ = True
+
+ # --------------------------------------
+ def lectureFichierIniStandard(self):
+ # --------------------------------------
+
+ name = "prefs_" + self.appliEficas.code
+ try:
+ prefsCode = __import__(name)
+ except:
+ self.catalogues = []
+ print("pas de fichier de prefs")
+ return
+ for k in dir(prefsCode):
+ if k[0:1] != "__" and k[-1:-2] != "__":
+ valeur = getattr(prefsCode, k)
+ setattr(self, k, valeur)
+
+ # --------------------------------------
+ def lectureFichierIniIntegrateur(self):
+ # --------------------------------------
+ # Verifie l'existence du fichier "standard"
+ # appelle la lecture de ce fichier
+ clef = "PREFS_CATA_" + self.code
+ try:
+ repIntegrateur = os.path.abspath(os.environ[clef])
+ except:
+ return
+
+ fic_ini_integrateur = os.path.join(repIntegrateur, self.name)
+ if not os.path.isfile(fic_ini_integrateur):
+ return
+ with open(fic_ini_integrateur) as fd:
+ txt = fd.read()
+ d = locals()
+ try:
+ exec(txt, d)
+ except:
+ try:
+ from PyQt5.QtWidgets import QMessageBox
+
+ QMessageBox.critical(
+ None,
+ tr("Import du fichier de Configuration"),
+ tr(
+ "Erreur a la lecture du fichier de configuration %s ",
+ str(fic_ini_integrateur),
+ ),
+ )
+ except:
+ print(
+ "Erreur a la lecture du fichier de configuration %s ",
+ str(fic_ini_integrateur),
+ )
+ return
+ self.labels_eficas.append("rep_aide")
+ for k in self.labels_eficas:
+ try:
+ setattr(self, k, d[k])
+ except:
+ pass
+ # Glut pour les repertoires materiaux
+ # et pour la doc
+ for k in d:
+ if (k[0:8] == "rep_mat_") or (k[0:8] == "rep_doc_"):
+ setattr(self, k, d[k])
+
+ # --------------------------------------
+ def lectureFichierIniUtilisateur(self):
+ # --------------------------------------
+ # Surcharge les parametres standards par les parametres utilisateur s'ils existent
+ self.fic_ini_utilisateur = os.path.join(self.rep_user, self.name)
+ if not os.path.isfile(self.fic_ini_utilisateur):
+ return
+ with open(fic_ini_utilisateur) as fd:
+ txt = fd.read()
+ d = locals()
+ try:
+ exec(txt, d)
+ except:
+ l = traceback.format_exception(
+ sys.exc_info()[0], sys.exc_info()[1], sys.exc_info()[2]
+ )
+ try:
+ from PyQt5.QtWidgets import QMessageBox
+
+ QMessageBox.critical(
+ None,
+ tr("Import du fichier de Configuration"),
+ tr(
+ "Erreur a la lecture du fichier de configuration %s ",
+ str(fic_ini_integrateur),
+ ),
+ )
+ except:
+ print(
+ "Erreur a la lecture du fichier de configuration %s ",
+ str(fic_ini_integrateur),
+ )
+ for k in self.labels_user:
+ try:
+ setattr(self, k, d[k])
+ except:
+ pass
+ for k in d:
+ if (k[0:8] == "rep_mat_") or (k[0:8] == "rep_doc_"):
+ setattr(self, k, d[k])
+
+ # --------------------------------------
+ def saveParams(self):
+ # --------------------------------------
+ # sauvegarde
+ # les nouveaux parametres dans le fichier de configuration utilisateur
+ #
+ texte = ""
+ for clef in self.labels_user:
+ if hasattr(self, clef):
+ valeur = getattr(self, clef)
+ texte = texte + clef + " = " + repr(valeur) + "\n"
+ # Glut pour les repertoires materiaux
+ # et pour la doc
+ for k in dir(self):
+ if (k[0:8] == "rep_mat_") or (k[0:8] == "rep_doc_"):
+ valeur = getattr(self, k)
+ texte = texte + k + " = " + repr(valeur) + "\n"
+
+ f = open(self.fic_ini_utilisateur, "w+")
+ f.write(texte)
+ f.close()
+
+
+#
+
+
+def makeConfig(appliEficas, rep):
+ return configBase(appliEficas, rep)
diff --git a/InterfaceGUI/QT5/editor.py b/InterfaceGUI/QT5/editor.py
new file mode 100755
index 00000000..f19e3635
--- /dev/null
+++ b/InterfaceGUI/QT5/editor.py
@@ -0,0 +1,1522 @@
+# -*- 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 types, sys, os, re
+import subprocess
+
+from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter, QLabel
+from PyQt5.QtGui import QPalette, QFont
+from PyQt5.QtCore import QProcess, QFileInfo, QTimer, Qt, QDir, QSize, QProcessEnvironment
+
+import traceback
+
+# Modules Eficas
+from Extensions.i18n import tr
+
+from Editeur import session
+from Editeur import comploader
+from Editeur import Objecttreeitem
+from InterfaceGUI.QT5 import browser
+
+from desBaseWidget import Ui_baseWidget
+from InterfaceGUI.QT5.monViewTexte import ViewText
+from monWidgetCreeParam import MonWidgetCreeParam
+
+DictExtensions = {"MAP": ".map", "TELEMAC": ".cas"}
+debug = False
+
+
+from InterfaceGUI.editorSsIhm import JDCEditorSsIhm
+
+
+class JDCEditor(JDCEditorSsIhm, Ui_baseWidget, QWidget):
+# -------------------------------------------------- #
+ """
+ Editeur de jdc
+ """
+
+ # ----------------------------------------
+ # Methodes faisant appel a ssIhm
+ # ----------------------------------------
+
+ def __init__( self, appliEficas, fichier=None, jdc=None, QWParent=None, units=None, include=0):
+ # ------------------------------------------------------------------------------------------------
+
+ QWidget.__init__(self, None)
+ self.setupUi(self)
+
+ self.inhibeSplitter = 0
+ self.widgetOptionnel = None
+ self.fenetreCentraleAffichee = None
+ self.dejaDansPlieTout = False
+ self.listeDesListesOuvertes = set()
+ if appliEficas != None and hasattr(appliEficas, "statusBar"):
+ self.sb = appliEficas.statusBar()
+ else:
+ self.sb = None
+ self.QWParent = QWParent
+
+ JDCEditorSsIhm.__init__(self, appliEficas, fichier, jdc, units, include)
+ if self.jdc:
+ comploader.chargerComposants(self.appliEficas.GUIPath)
+ self.jdc_item = Objecttreeitem.makeObjecttreeitem(self, "nom", self.jdc)
+
+ # Particularites IHM : met la fenetre a jour
+ self.initSplitterSizes()
+
+ self.afficheListesPliees = self.maConfiguration.afficheListesPliees
+ if self.code in ["MAP", "CARMELCND", "PSEN"]:
+ self.maConfiguration.afficheCommandesPliees = False
+
+ if self.maConfiguration.closeArbre:
+ self.fermeArbre()
+ if self.maConfiguration.closeOptionnel:
+ self.fermeOptionnel()
+ if self.maConfiguration.boutonDsMenuBar:
+ self.appliEficas.remplitIconesCommandes()
+
+ self.formatFichierOut = self.appliEficas.formatFichierOut
+ self.formatFichierIn = self.appliEficas.formatFichierIn
+
+ self.node_selected = []
+ self.deplier = True
+ self.message = ""
+ self.afficheApresInsert = False
+ if self.maConfiguration.closeArbre:
+ self.afficheApresInsert = True
+ if self.code in ["Adao", "ADAO", "MAP"]:
+ self.afficheApresInsert = True
+ if self.code in [ "TELEMAC", ]:
+ self.enteteQTree = "premier"
+ else:
+ self.enteteQTree = "complet"
+ if self.code in ["Adao", "ADAO", "TELEMAC", "VP"]:
+ self.affichePlie = True
+ else:
+ self.affichePlie = False
+
+ #self.commandesOrdreCatalogue = self.readercata.commandesOrdreCatalogue
+
+ if self.appliEficas.readercata.demandeCatalogue == True:
+ nomFichierTranslation = (
+ "translatorFichier" + "_" + str(self.appliEficas.readercata.labelCode)
+ )
+ if hasattr(self.appliEficas.maConfiguration, nomFichierTranslation):
+ translatorFichier = getattr(
+ self.appliEficas.maConfiguration, nomFichierTranslation
+ )
+ from Extensions import localisation
+
+ localisation.localise(
+ None, self.appliEficas.langue, translatorFichier=translatorFichier
+ )
+
+ if self.jdc_item and self.appliEficas.ssIhm == False:
+ self.tree = browser.JDCTree(self.jdc_item, self)
+ self.appliEficas.construitMenu()
+
+ self.adjustSize()
+
+ # -------------------------------#
+ def readFile(self, fn):
+ # --------------------------------#
+ """
+ Public slot to read the text from a file.
+ @param fn filename to read from (string or QString)
+ """
+
+ jdc = JDCEditorSsIhm.readFile(self, fn)
+
+ # Particularites IHM : met le titre de la fenetre a jour
+ # qApp.restoreOverrideCursor()
+ if self.fileInfo != None:
+ self.lastModified = self.fileInfo.lastModified()
+ nouveauTitre = self.titre + " " + os.path.basename(self.fichier)
+ self.appliEficas.setWindowTitle(nouveauTitre)
+
+ return jdc
+
+ # ---------------------------------------------
+ # Methodes Inchangees
+ # ---------------------------------------------
+ # _newJDC
+ # _newJDCInclude
+ # __generateTempFilename
+ # getSource
+ # generDico
+ # viewJdcSource
+ # viewJdcPy
+ # viewJdcRapport
+ # getFileName
+ # initModif
+ # writeFile
+ # getTextJDC
+ # verifieChecksum
+ # getChecksum
+ # getDico
+ # chercheGroupes
+ # chercheDico
+ # saveFileLegerAs
+
+ # ---------------------------------------------
+ # Methodes Surchargees
+ # ---------------------------------------------
+
+ # -----------------------------------------------------------------------#
+ def _viewText(self, txt, caption="FILE_VIEWER", largeur=1200, hauteur=600):
+ # --------------------------------------------------------------------#
+ w = ViewText(self.QWParent, self, caption, txt, largeur, hauteur)
+ w.show()
+
+ # --------------------------------#
+ def informe(self, titre, txt, critique=True):
+ # --------------------------------#
+ if critique:
+ self.afficheInfos(tr(txt), Qt.red)
+ QMessageBox.critical(self, tr(titre), tr(txt))
+ else:
+ QMessageBox.warning(self, tr(titre), tr(txt))
+
+ # --------------------------------#
+ def ajoutCommentaire(self):
+ # --------------------------------#
+ if self.tree.selectedItems() == []:
+ QMessageBox.warning(
+ self,
+ tr("Pas de noeud selectionne"),
+ tr(
+ "Selectionnez un Noeud \nLe commentaire sera place apres le noeud selectionne"
+ ),
+ )
+ return
+ noeudAvantCommentaire = self.tree.selectedItems()[0]
+ if noeudAvantCommentaire == self.tree.racine:
+ self.tree.racine.appendChild("COMMENTAIRE", pos=0)
+ return
+ noeudAvantCommentaire.addComment(True)
+
+ # -----------------------------------------------------------------------------------------------#
+ def _viewTextExecute(
+ self, txt, prefix, suffix, fichierExe=None, shell="sh", texteCommande=None
+ ):
+ # ----------------------------------------------------------------------------------------------#
+ self.myWidget = ViewText(self.QWParent)
+ self.myWidget.setWindowTitle("execution")
+ self.myWidget.view.setFont(QFont("Monospace"))
+ self.monExe = QProcess(self.myWidget)
+ pid = self.monExe.pid()
+ if not fichierExe and txt:
+ fichierExe = self.generateTempFilename(prefix, suffix=".sh")
+ f = open(fichierExe, "self.myWidget")
+ f.write(txt)
+ f.close()
+ self.monExe.readyReadStandardOutput.connect(self.readFromStdOut)
+ self.monExe.readyReadStandardError.connect(self.readFromStdErr)
+ if texteCommande != None:
+ exe = texteCommande
+ else:
+ exe = shell + " " + fichierExe
+ monEnv = QProcessEnvironment.systemEnvironment()
+ monEnv.insert("COLUMNS", "500")
+ self.monExe.setProcessEnvironment(monEnv)
+ self.monExe.start(exe)
+ self.monExe.closeWriteChannel()
+ self.myWidget.exec_()
+ if self.monExe != None:
+ self.monExe.readyReadStandardOutput.disconnect()
+ self.monExe.readyReadStandardError.disconnect()
+ if txt:
+ commande = "rm " + fichierExe
+ os.system(commande)
+ return 1
+
+ def readFromStdErr(self):
+ a = self.monExe.readAllStandardError()
+ chaine = str(a.data(), encoding="utf-8")
+ self.myWidget.view.append(chaine)
+ # self.myWidget.view.append(str(a.data()))
+
+ def readFromStdOut(self):
+ a = self.monExe.readAllStandardOutput()
+ chaine = str(a.data(), encoding="utf-8")
+ self.myWidget.view.append(chaine)
+
+ # self.wmyWidget.view.append(str(a.data()))
+
+ # -----------------------#
+ def gestionParam(self):
+ # -----------------------#
+ w = MonWidgetCreeParam(self)
+ w.show()
+
+ # ----------------#
+ def closeIt(self):
+ # ----------------#
+ """
+ Public method called by the viewmanager to finally get rid of us.
+ """
+ if self.jdc:
+ self.jdc.supprime()
+ self.close()
+
+ # ----------------------------------------------#
+ def afficheInfos(self, message, couleur=Qt.black):
+ # ----------------------------------------------#
+ if couleur == "red":
+ couleur = Qt.red
+ if self.sb:
+ mapalette = self.sb.palette()
+ mapalette.setColor(QPalette.WindowText, couleur)
+ self.sb.setPalette(mapalette)
+ self.sb.showMessage(message, 4000)
+ self.couleur = couleur
+
+ # ------------------------------#
+ def afficheAlerte(self, titre, message):
+ # ------------------------------#
+ # appele par I_MACRO_ETAPE
+ QMessageBox.information(self, titre, message)
+
+ # -----------------------------------#
+ def afficheCommentaire(self, message):
+ # -----------------------------------#
+ self.labelCommentaire.setText(message)
+ QTimer.singleShot(6000, self.rendInvisible)
+
+ # ----------------------#
+ def rendInvisible(self):
+ # ----------------------#
+ self.labelCommentaire.setText("")
+
+ # ---------------------------------------#
+ def chercheNoeudSelectionne(self, copie=1):
+ # ---------------------------------------#
+ """
+ appele par Cut et Copy pour positionner self.node_selected
+ """
+ self.node_selected = []
+ if len(self.tree.selectedItems()) == 0:
+ return
+ self.node_selected = self.tree.selectedItems()
+
+ # ---------------------#
+ def handleSupprimer(self):
+ # ---------------------#
+ self.chercheNoeudSelectionne()
+ if len(self.node_selected) == 0:
+ return
+ self.QWParent.noeud_a_editer = []
+ if self.node_selected[0] == self.tree.racine:
+ return
+ if len(self.node_selected) == 1:
+ self.node_selected[0].delete()
+ else:
+ self.node_selected[0].deleteMultiple(self.node_selected)
+
+ # ---------------------#
+ def handleRechercher(self):
+ # ---------------------#
+ from .monRecherche import DRecherche
+
+ monRechercheDialg = DRecherche(parent=self, fl=0)
+ monRechercheDialg.show()
+
+ # --------------------------------#
+ def handleRechercherDsCatalogue(self):
+ # -----------------------------#
+ from .monRechercheCatalogue import DRechercheCatalogue
+
+ monRechercheDialg = DRechercheCatalogue(self.QWParent, self)
+ monRechercheDialg.show()
+
+ # ---------------------#
+ def handleDeplier(self):
+ # ---------------------#
+ if self.tree == None:
+ return
+ # self.tree.collapseAll()
+ if self.deplier:
+ # print "je plie"
+ self.tree.expandItem(self.tree.topLevelItem(0))
+ self.deplier = False
+ if self.fenetreCentraleAffichee != None:
+ if hasattr(self.fenetreCentraleAffichee.node, "plieToutEtReaffiche"):
+ self.fenetreCentraleAffichee.node.plieToutEtReaffiche()
+ else:
+ # print "je deplie"
+ self.tree.expandItem(self.tree.topLevelItem(0))
+ self.deplier = True
+ if self.fenetreCentraleAffichee != None:
+ if hasattr(self.fenetreCentraleAffichee.node, "deplieToutEtReaffiche"):
+ self.fenetreCentraleAffichee.node.deplieToutEtReaffiche()
+
+ # ---------------------#
+ def handleEditCut(self):
+ # ---------------------#
+ """
+ Stocke dans Eficas.noeud_a_editer le noeud a couper
+ """
+ # print "handleEditCut"
+ self.chercheNoeudSelectionne()
+ self.QWParent.edit = "couper"
+ self.QWParent.noeud_a_editer = self.node_selected
+
+ # -----------------------#
+ def handleEditCopy(self):
+ # -----------------------#
+ """
+ Stocke dans Eficas.noeud_a_editer le noeud a copier
+ """
+ self.chercheNoeudSelectionne()
+ if len(self.node_selected) == 0:
+ return
+ if len(self.node_selected) == 1:
+ self.node_selected[0].updateNodeLabelInBlue()
+ else:
+ self.node_selected[0].updatePlusieursNodeLabelInBlue(self.node_selected)
+ self.QWParent.edit = "copier"
+ self.QWParent.noeud_a_editer = self.node_selected
+
+ # ------------------------#
+ def handleEditPaste(self):
+ # ------------------------#
+ """
+ Lance la copie de l'objet place dans self.QWParent.noeud_a_editer
+ Ne permet que la copie d'objets de type Commande ou MCF
+ """
+ self.chercheNoeudSelectionne()
+ if (not (hasattr(self.QWParent, "noeud_a_editer"))) or len(
+ self.QWParent.noeud_a_editer
+ ) == 0:
+ QMessageBox.information(
+ self,
+ tr("Copie impossible"),
+ tr("Veuillez selectionner un objet a copier"),
+ )
+ return
+ if len(self.node_selected) != 1:
+ QMessageBox.information(
+ self,
+ tr("Copie impossible"),
+ tr(
+ "Veuillez selectionner un seul objet : la copie se fera apres le noeud selectionne"
+ ),
+ )
+ return
+ noeudOuColler = self.node_selected[0]
+
+ if len(self.QWParent.noeud_a_editer) != 1:
+ # self.handleEditPasteMultiple()
+ QMessageBox.information(
+ self, tr("Copie impossible"), tr("Aucun Objet n a ete copie ou coupe")
+ )
+ return
+
+ noeudACopier = self.QWParent.noeud_a_editer[0]
+
+ if self.QWParent.edit != "couper":
+ # print (noeudOuColler.item.parent.getChild(noeudOuColler.item.nom))
+ try:
+ if noeudOuColler == self.tree.racine:
+ child = noeudOuColler.doPastePremier(noeudACopier)
+ else:
+ child = noeudACopier.doPaste(noeudOuColler, "after")
+
+ if child == None or child == 0:
+ QMessageBox.critical(
+ self,
+ tr("Copie refusee"),
+ tr("Eficas n a pas reussi a copier l objet"),
+ )
+ self.message = ""
+ self.afficheInfos("Copie refusee", Qt.red)
+ if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
+ try:
+ nom = noeudACopier.item.sd.nom
+ child.item.nommeSd(nom)
+ except:
+ pass
+ return
+ self.initModif()
+ child.select()
+ except:
+ traceback.print_exc()
+ QMessageBox.critical(
+ self, tr("Copie refusee"), tr("Copie refusee pour ce type d objet")
+ )
+ self.message = ""
+ self.afficheInfos("Copie refusee", Qt.red)
+ return
+
+ # il faut declarer le JDCDisplay_courant modifie
+ # suppression eventuelle du noeud selectionne
+ # si possible on renomme l objet comme le noeud couper
+
+ if self.QWParent.edit == "couper":
+ if noeudACopier.treeParent.editor != noeudOuColler.treeParent.editor:
+ QMessageBox.critical(
+ self,
+ tr("Deplacement refuse"),
+ tr(
+ "Deplacement refuse entre 2 fichiers. Seule la copie est autorisee "
+ ),
+ )
+
+ # if 1:
+ try:
+ # indexNoeudACopier=noeudACopier.treeParent.children.index(noeudACopier)
+ indexNoeudACopier = self.getTreeIndex(noeudACopier)
+ noeudACopier.treeParent.item.deplaceEntite(
+ indexNoeudACopier, indexNoeudOuColler, pos
+ )
+ noeudACopier.treeParent.buildChildren()
+
+ # else:
+ except:
+ pass
+ self.QWParent.noeud_a_editer = []
+
+ # on rend la copie a nouveau possible en liberant le flag edit
+ self.QWParent.edit = "copier"
+ noeudACopier.select()
+
+ # ----------------------------------#
+ def handleDeplaceMultiple(self):
+ # ----------------------------------#
+ pass
+
+ # ----------------------------------#
+ def handleEditPasteMultiple(self):
+ # ----------------------------------#
+
+ # On ne garde que les niveaux "Etape"
+ # On insere dans l'ordre du JDC
+ listeNoeudsACouper = []
+ listeIndex = []
+ listeChild = []
+ listeItem = []
+ from InterfaceGUI.QT5 import compojdc
+
+ noeudOuColler = self.node_selected[0]
+ if not (isinstance(noeudOuColler.treeParent, compojdc.Node)):
+ QMessageBox.information(
+ self,
+ tr(
+ "Copie impossible a cet endroit",
+ ),
+ tr(
+ "Veuillez selectionner une commande, un parametre, un commentaire ou une macro"
+ ),
+ )
+ return
+ indexNoeudOuColler = noeudOuColler.treeParent.children.index(noeudOuColler)
+
+ for noeud in self.QWParent.noeud_a_editer:
+ if not (isinstance(noeud.treeParent, compojdc.Node)):
+ continue
+ indexInTree = noeud.treeParent.children.index(noeud)
+ indice = 0
+ for index in listeIndex:
+ if index < indexInTree:
+ indice = indice + 1
+ listeIndex.insert(indice, indexInTree)
+ listeNoeudsACouper.insert(indice, noeud)
+
+ noeudJdc = noeudOuColler.treeParent
+ dejaCrees = 0
+ # on les cree a l'envers parcequ'on ajoute a NoeudOuColler
+ listeIndex.reverse()
+ for index in listeIndex:
+ indexTravail = index
+ if indexNoeudOuColler < index:
+ indexTravail = indexTravail + dejaCrees
+ noeudOuColler = noeudJdc.children[indexNoeudOuColler]
+ noeud = noeudJdc.children[indexTravail]
+ child = noeud.doPaste(noeudOuColler)
+ listeChild.append(child)
+ dejaCrees = dejaCrees + 1
+
+ self.QWParent.noeud_a_editer = []
+ for i in range(len(listeIndex)):
+ noeud = noeudJdc.children[indexNoeudOuColler + 1 + i]
+ self.QWParent.noeud_a_editer.append(noeud)
+
+ listeASupprimer = []
+ if self.QWParent.edit != "couper":
+ return
+
+ for index in listeIndex:
+ indexTravail = index
+ if indexNoeudOuColler < index:
+ indexTravail = indexTravail + (len(listeIndex))
+ noeud = noeudJdc.children[indexTravail]
+
+ listeItem.append(noeud.item)
+ listeASupprimer.append(noeud)
+
+ for i in range(len(listeChild)):
+ self.tree.item.suppItem(listeItem[i])
+ listeChild[i].item.update(listeItem[i])
+
+ self.QWParent.noeud_a_editer = []
+
+ # ----------------------------------#
+ def handleAjoutEtape(self, nomEtape):
+ # ----------------------------------#
+ self.chercheNoeudSelectionne()
+ if len(self.node_selected) == 0 or self.node_selected[0] == self.tree.racine:
+ nodeOuAjouter = self.tree.racine
+ nouveau = nodeOuAjouter.appendChild(nomEtape, pos="first")
+ else:
+ nodeOuAjouter = self.node_selected[0]
+ if nodeOuAjouter != self.tree.racine:
+ while nodeOuAjouter.treeParent != self.tree.racine:
+ nodeOuAjouter = nodeOuAjouter.treeParent
+ nouveau = nodeOuAjouter.appendBrother(nomEtape)
+ try:
+ self.node_selected[0].setSelected(False)
+ except:
+ pass
+ nouveau.setSelected(True)
+ nouveau.affichePanneau()
+
+ # ---------------------------#
+ def getFileVariable(self):
+ # ---------------------------#
+ titre = tr("Choix d'un fichier XML")
+ texte = tr("Le fichier contient une commande MODEL\n")
+ texte = texte + tr(
+ "Donnez le nom du fichier XML qui contient la description des variables"
+ )
+ QMessageBox.information(self, titre, tr(texte))
+
+ fichier = QFileDialog.getOpenFileName(
+ self.appliEficas,
+ tr("Ouvrir Fichier"),
+ self.appliEficas.maConfiguration.savedir,
+ tr("Wrapper Files (*.xml);;" "All Files (*)"),
+ )
+ return fichier
+
+ # ------------#
+ def run(self):
+ # ------------#
+ fonction = "run" + self.code
+ if fonction in JDCEditor.__dict__:
+ JDCEditor.__dict__[fonction](
+ self,
+ )
+
+ # ------------#
+ def saveRun(self):
+ # ------------#
+ fonction = "saveRun" + self.code
+ if fonction in JDCEditor.__dict__:
+ JDCEditor.__dict__[fonction](
+ self,
+ )
+
+ # ---------------------------------------------
+ # Methodes Non Crees dans ssIHM
+ # ---------------------------------------------
+ # ---------------#
+ def runVP(self):
+ # ---------------#
+ texte = self.getTextJDC("MAPVp", pourRun=1)
+ print(texte)
+
+ # ---------------#
+ def runMAP(self):
+ # ---------------#
+
+ if not (self.jdc.isValid()):
+ QMessageBox.critical(
+ self,
+ tr("Execution impossible "),
+ tr("le JDC doit etre valide pour une execution MAP"),
+ )
+ return
+ if len(self.jdc.etapes) != 1:
+ QMessageBox.critical(
+ self,
+ tr("Execution impossible "),
+ tr("le JDC doit contenir un et un seul composant"),
+ )
+ return
+ if self.modified or self.fichier == None:
+ self.fichierMapInput = self.generateTempFilename(
+ prefix="map_run", suffix=".map"
+ )
+ texte = self.getTextJDC("MAP")
+ self.writeFile(self.fichierMapInput, txt=texte)
+ else:
+ self.fichierMapInput = self.fichier
+ composant = self.jdc.etapes[0].nom.lower()[0:-5]
+
+ # :TRICKY: to determine if a component requires SALOME, loads the component from Eficas catalog
+ # then instantiate corresponding class and call getUseSalome() method
+ try:
+ from mapengine.spec import factory
+
+ mapComponent = factory.new(composant)[0]
+
+ command = "map"
+ if mapComponent.getUseSalome():
+ command += " -r sappli"
+ textePython = (
+ command + " run -n " + composant + " -i " + self.fichierMapInput
+ )
+
+ # textePython="ls -l"
+ self._viewTextExecute(textePython, "map_run", ".sh")
+ # try:
+ # commande="rm "+self.fichierMapInput
+ # os.system(commande)
+ # except :
+ # pass
+ except Exception as e:
+ print((traceback.print_exc()))
+
+ # -------------------#
+ def runZCRACKS(self):
+ # -------------------#
+ if not (self.jdc.isValid()):
+ QMessageBox.critical(
+ self,
+ tr("Execution impossible "),
+ tr("le JDC doit etre valide pour une execution "),
+ )
+ return
+ if self.modified or self.fichier == None:
+ # if 1:
+ self.fichierZcracksInput = self.generateTempFilename(
+ prefix="zcracks_run", suffix=".z7p"
+ )
+ texte = self.getTextJDC("ZCRACKS", pourRun=1)
+ self.writeFile(self.fichierZcracksInput, txt=texte)
+ else:
+ self.fichierZcracksInput = self.fichier
+ try:
+ # commande ="Zrun -zp "
+ commande = "more "
+ textePython = commande + self.fichierZcracksInput
+ self._viewTextExecute(textePython, "run_zcracks", ".sh")
+ except Exception as e:
+ print((traceback.print_exc()))
+
+ # -------------------#
+ def runCARMELCND(self):
+ # -------------------#
+ # if not(self.jdc.isValid()):
+ # QMessageBox.critical( self, tr( "Execution impossible "),tr("le JDC doit etre valide pour une execution "))
+ # return
+ if self.modified or self.fichier == None:
+ QMessageBox.critical(
+ self,
+ tr("Execution impossible "),
+ tr("Sauvegarder SVP avant l'execution "),
+ )
+ return
+ if not hasattr(self, "generator"):
+ texte = self.getTextJDC(self.formatFichierOut)
+ from PrepareRunCarmel import prepareRunCarmel
+
+ fichierGenerique = os.path.basename(self.fichier).split(".")[0]
+ repMed = os.path.dirname(self.fichier)
+ repExeCarmel = self.generator.get_repExeCarmel()
+ textePython = prepareRunCarmel(repExeCarmel, repMed, fichierGenerique)
+ nomFichier = self.generateTempFilename("carmel_run", suffix=".sh")
+ f = open(nomFichier, "w")
+ f.write(textePython)
+ f.close()
+ commande = "xterm -e sh " + nomFichier + "\n"
+ os.system(commande)
+
+ # -------------------#
+ def runCarmelCS(self):
+ # -------------------#
+ try:
+ commande = "runSession pilotyacsCS.py"
+ os.system(commande)
+ except Exception as e:
+ print((traceback.print_exc()))
+
+ # -----------------------------------------------------#
+ def determineNomFichier(self, path, extension):
+ # -----------------------------------------------------#
+ if self.appliEficas.code in DictExtensions:
+ chaine1 = (
+ DictExtensions[self.appliEficas.code]
+ + " (*."
+ + DictExtensions[self.appliEficas.code]
+ + ");;"
+ )
+ extensions = tr(chaine1 + "All Files (*)")
+ else:
+ extensions = tr("JDC (*.comm);;" "All Files (*)")
+
+ if self.appliEficas.code == "MAP":
+ extensions = extensions + ";; Run (*.input);;"
+
+ fn = QFileDialog.getSaveFileName(
+ self,
+ tr("sauvegarde"),
+ path,
+ extensions,
+ None,
+ QFileDialog.DontConfirmOverwrite,
+ )
+ if fn == None:
+ return (0, None)
+ fn = fn[0]
+ if fn == "":
+ return (0, None)
+
+ ext = QFileInfo(fn).suffix()
+ if ext == "":
+ fn += extension
+
+ if QFileInfo(fn).exists():
+ msgBox = QMessageBox(self)
+ msgBox.setWindowTitle(tr("Sauvegarde du Fichier"))
+ msgBox.setText(tr("Le fichier") + " " + str(fn) + " " + tr("existe deja"))
+ msgBox.addButton(tr("&Ecraser"), 0)
+ msgBox.addButton(tr("&Abandonner"), 1)
+ abort = msgBox.exec_()
+ if abort == 1:
+ return (0, "")
+ return (1, fn)
+
+ # -----------------#
+ def saveRunMAP(self):
+ # -----------------#
+ extension = ".input"
+ if not (self.jdc.isValid()):
+ QMessageBox.critical(
+ self,
+ tr("Sauvegarde de l'input impossible "),
+ tr("Un JdC valide est necessaire pour creer un .input"),
+ )
+ return
+ try:
+ composant = self.jdc.etapes[0].nom.lower()[0:-5]
+ except:
+ QMessageBox.critical(
+ self,
+ tr("Sauvegarde de l'input impossible "),
+ tr("Choix du composant obligatoire"),
+ )
+ return
+ if hasattr(self.maConfiguration, "savedir"):
+ path = self.maConfiguration.savedir
+ else:
+ path = "C:/"
+
+ monNomFichier = ""
+ if self.fichier is not None and self.fichier != "":
+ maBase = str(QFileInfo(self.fichier).baseName()) + ".input"
+ monPath = str(QFileInfo(self.fichier).absolutePath())
+ monNomFichier = os.path.join(monPath, maBase)
+ elif hasattr(self, "monNomFichierInput"):
+ monNomFichier = self.monNomFichierInput
+
+ monDialog = QFileDialog(self.appliEficas)
+ monDialog.setDirectory(path)
+ monDialog.setWindowTitle("Save")
+
+ for c in monDialog.children():
+ if isinstance(c, QDialogButtonBox):
+ for b in c.children():
+ if isinstance(b, QPushButton):
+ avant = b.text()
+ if avant == "&Open":
+ b.setText("Save")
+ mesFiltres = "input Map (*.input);;All Files (*)"
+ monDialog.setNameFilters(mesFiltres)
+ if monNomFichier != "":
+ monDialog.selectFile(monNomFichier)
+ BOk = monDialog.exec_()
+ if BOk == 0:
+ return
+ fn = str(monDialog.selectedFiles()[0])
+ if fn == "" or fn == None:
+ return
+ if not fn.endswith(".input"):
+ fn += ".input"
+ self.monNomFichierInput = fn
+
+ if (
+ not hasattr(self, "fichierMapInput")
+ or not self.fichierMapInput
+ or not os.path.exists(self.fichierMapInput)
+ ):
+ self.fichierMapInput = self.generateTempFilename(
+ prefix="map_run", suffix=".map"
+ )
+ texte = self.getTextJDC("MAP")
+ self.writeFile(self.fichierMapInput, txt=texte)
+
+ cmd = (
+ "map gen -t dat -n "
+ + composant
+ + " -i "
+ + self.fichierMapInput
+ + " -o "
+ + fn
+ )
+ p = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
+ (output, err) = p.communicate()
+
+ # -----------------#
+ def saveRunPSEN(self):
+ # -----------------#
+ # print ("saveRunPSEN")
+ self.saveFile()
+
+ # -----------------------------------------#
+ def handleAjoutGroup(self, listeGroup):
+ # -----------------------------------------#
+ try:
+ # if 1:
+ from ajoutGroupe import handleAjoutGroupFiltre
+
+ # print listeGroup
+ handleAjoutGroupFiltre(self, listeGroup)
+ # print "apres handleAjoutGroupFiltre"
+ except:
+ # else :
+ pass
+
+ # -----------------------------------------------------------------#
+ def saveCompleteFile(self, path=None, saveas=0, formatLigne="beautifie"):
+ # -----------------------------------------------------------------#
+ extension = ".casR"
+ fn = self.fichierComplet
+ # saveas=True # Pour forcer le nom
+ self.generator = self.maConfiguration.mesGenerators.plugins[
+ self.formatFichierOut
+ ]()
+ if self.fichierComplet is None or saveas:
+ if path is None:
+ path = self.maConfiguration.savedir
+ bOK, fn = self.determineNomFichier(path, extension)
+ if bOK == 0:
+ return (0, None)
+ if fn == None:
+ return (0, None)
+ if fn == "":
+ return (0, None)
+
+ ulfile = os.path.abspath(fn)
+ self.appliEficas.maConfiguration.savedir = os.path.split(ulfile)[0]
+ fn = QDir.toNativeSeparators(fn)
+
+ self.fichierComplet = os.path.splitext(fn)[0] + extension
+
+ if hasattr(self.generator, "writeComplet"):
+ self.generator.writeComplet(
+ self.fichierComplet,
+ self.jdc,
+ config=self.appliEficas.maConfiguration,
+ appliEficas=self.appliEficas,
+ )
+
+ if self.salome:
+ self.appliEficas.addJdcInSalome(self.fichierComplet)
+
+ self.modified = 0
+ nouveauTitre = (
+ self.titre + " " + str(os.path.basename(self.fichierComplet))
+ )
+ self.appliEficas.setWindowTitle(nouveauTitre)
+ return (1, self.fichierComplet)
+
+ # -----------------------------------------------------------------#
+ def saveFile(self, path=None, saveas=0, formatLigne="beautifie"):
+ # -----------------------------------------------------------------#
+ """
+ Public slot to save the text to a file.
+
+ @param path directory to save the file in (string or QString)
+ @return tuple of two values (boolean, string) giving a success indicator and
+ the name of the saved file
+ """
+
+ self.modified = 1
+ if not self.modified and not saveas:
+ return (0, None) # do nothing if text wasn't changed
+
+ if self.appliEficas.code in DictExtensions:
+ extension = DictExtensions[self.appliEficas.code]
+ else:
+ extension = ".comm"
+
+ newName = None
+ fn = self.fichier
+ if self.fichier is None or saveas:
+ if path is None:
+ path = self.maConfiguration.savedir
+ bOK, fn = self.determineNomFichier(path, extension)
+ if bOK == 0:
+ return (0, None)
+ if fn == None:
+ return (0, None)
+ if fn == "":
+ return (0, None)
+
+ ulfile = os.path.abspath(fn)
+ self.appliEficas.maConfiguration.savedir = os.path.split(ulfile)[0]
+ fn = QDir.toNativeSeparators(fn)
+ newName = fn
+
+ if not (self.writeFile(fn, formatLigne=formatLigne)):
+ return (0, None)
+ self.fichier = fn
+ self.modified = False
+ if self.fileInfo is None or saveas:
+ self.fileInfo = QFileInfo(self.fichier)
+ self.fileInfo.setCaching(0)
+ self.lastModified = self.fileInfo.lastModified()
+ if newName is not None:
+ self.appliEficas.addToRecentList(newName)
+ self.tree.racine.item.getObject().nom = os.path.basename(newName)
+ self.tree.racine.updateNodeLabel()
+
+ if self.jdc.cata.modeleMetier:
+ self.jdc.toXml(self.fichier)
+ if self.jdc.cata.modeleMetier and self.jdc.isValid():
+ if self.generator != self.XMLGenerator:
+ self.XMLGenerator.gener(self.jdc)
+ self.XMLGenerator.writeDefault(fn)
+
+ if self.jdc.isValid() != 0 and hasattr(self.generator, "writeDefault"):
+ # if hasattr(self.generator, "writeDefault"):
+ self.generator.writeDefault(fn)
+ elif self.code == "TELEMAC" and hasattr(self.generator, "writeDefault"):
+ msgBox = QMessageBox(None)
+ msgBox.setWindowTitle(tr("Fichier .cas invalide / incomplet"))
+ msgBox.setText(tr("Le fichier .cas est invalide / incomplet"))
+ msgBox.addButton(tr("&Sauvegarder"), 1)
+ msgBox.addButton(tr("&Quitter sans sauvegarder"), 0)
+ msgBox.addButton(tr("&Annuler"), 2)
+ res = msgBox.exec_()
+ if res == 0:
+ self.generator.writeDefault(fn)
+ return (1, self.fichier)
+ if res == 2:
+ return (0, None)
+ if self.appliEficas.salome:
+ self.appliEficas.close()
+ else:
+ sys.exit(1)
+
+ if self.salome:
+ self.appliEficas.addJdcInSalome(self.fichier)
+ self.modified = 0
+ nouveauTitre = (
+ self.titre + " " + str(os.path.basename(self.fichier))
+ )
+ self.appliEficas.setWindowTitle(nouveauTitre)
+
+ return (1, self.fichier)
+
+ # -------------------------------------------#
+ def sauvePourPersalys(self, fichier=None):
+ # -------------------------------------------#
+ if self.jdc.isValid() == 0:
+ self.informe(
+ "Fichier invalide/incomplet",
+ "Impossible de sauvegarder l étude Persalys",
+ critique=False,
+ )
+ return
+ if self.fichier is None:
+ if path is None:
+ path = self.maConfiguration.savedir
+ bOK, fn = self.determineNomFichier(path, "comm")
+ if bOK == 0:
+ return (0, None)
+ if fn == None:
+ return (0, None)
+ if fn == "":
+ return (0, None)
+ ulfile = os.path.abspath(fn)
+ self.appliEficas.maConfiguration.savedir = os.path.split(ulfile)[0]
+ fn = QDir.toNativeSeparators(fn)
+ self.fichier = fn
+ else:
+ fn = self.fichier
+ ret, comm = JDCEditorSsIhm.sauvePourPersalys(self, fn)
+ if not ret:
+ if not comm:
+ comm = "Impossible de sauvegarder l étude Persalys"
+ self.informe(" invalide/incomplet", comm, critique=False)
+ return
+
+ # -----------------------------------------------#
+ def saveUQFile(self, fichier=None, path=None):
+ # ------------------------------------------------#
+ if self.fichier is None:
+ if path is None:
+ path = self.maConfiguration.savedir
+ bOK, fn = self.determineNomFichier(path, "comm")
+ if bOK == 0:
+ return (0, None)
+ if fn == None:
+ return (0, None)
+ if fn == "":
+ return (0, None)
+ ulfile = os.path.abspath(fn)
+ self.appliEficas.maConfiguration.savedir = os.path.split(ulfile)[0]
+ print(fn)
+ fn = QDir.toNativeSeparators(fn)
+ self.fichier = fn
+ else:
+ fn = self.fichier
+
+ if self.jdc.isValid() == 0:
+ msgBox = QMessageBox(None)
+ msgBox.setWindowTitle(tr("Fichier invalide / incomplet"))
+ msgBox.setText(
+ tr(
+ "Le fichier .comm est invalide / incomplet \n Seuls les .comm et _det.comm seront sauvegardes"
+ )
+ )
+ msgBox.addButton(tr("&Sauvegarder les .comm et _det.comm"), 0)
+ msgBox.addButton(tr("&Quitter sans sauvegarder"), 1)
+ msgBox.addButton(tr("&Annuler"), 2)
+ res = msgBox.exec_()
+ if res == 2:
+ return (0, None)
+ if res == 0:
+ ret, fichier = JDCEditorSsIhm.saveUQFile(self, fn)
+ if ret:
+ self.fichier = fichier
+ if self.salome and ret:
+ self.appliEficas.addJdcInSalome(self.fichier)
+ return (1, self.fichier)
+ if self.appliEficas.salome:
+ self.appliEficas.close()
+ else:
+ sys.exit(1)
+
+ ret, comm = JDCEditorSsIhm.saveUQFile(self, fn)
+ if not ret:
+ if comm:
+ titre = "Probleme de sauvegarde des fichiers"
+ texte = "Impossible de sauvegarder {}".format(fn)
+ QMessageBox.information(self, titre, texte)
+ return (0, self.fichier)
+ return (1, self.fichier)
+
+ # -----------------------------------------------#
+ def exeUQ(self, fichier=None, path=None):
+ # ------------------------------------------------#
+ # if self.modified or not self.fichier :
+ sauvegarde, fichier = self.saveUQFile()
+ if not sauvegarde:
+ return 0
+ # texteCommande=' export COLUMNS=200;'
+ try:
+ virtual_env = os.environ["VIRTUAL_ENV"]
+ except:
+ titre = "Probleme d'environnement"
+ texte = "La variable d'environnement VIRTUAL_ENV n'est pas positionnée"
+ QMessageBox.information(self, titre, texte)
+ return False
+
+ texteCommande = (
+ os.path.join(os.environ["VIRTUAL_ENV"], "bin/salome")
+ + " start -k -t python3 "
+ + os.path.join(
+ self.generator.cheminFichierComm, self.generator.fichierUQExe
+ )
+ )
+ # self._viewTextExecute(None,None,None, fichierExe=self.generator.fichierUQExe, shell='python3')
+ # self._viewTextExecute('ls -l /tmp','essaiLs','.sh',)
+ # self._viewTextExecute(None,None,None, fichierExe='/home/A96028/QT5Dev/eficasRN/ReacteurNumerique/a.py',shell='python3',)
+ self._viewTextExecute(None, None, None, texteCommande=texteCommande)
+ return True
+
+ # ----------------------------------------------#
+ def sauveLigneFile(self):
+ # ----------------------------------------------#
+ self.modified = 1
+ return self.saveFile(formatLigne="Ligne")
+
+ # ----------------------------------------------#
+ def saveFileAs(self, path=None, fileName=None):
+ # ----------------------------------------------#
+ """
+ Public slot to save a file with a new name.
+
+ @param path directory to save the file in (string or QString)
+ @return tuple of two values (boolean, string) giving a success indicator and
+ the name of the saved file
+ """
+ if fileName != None:
+ self.fichier = fileName
+ return self.saveFile()
+ return self.saveFile(path, 1, "beautifie")
+
+ # ---------------------------------------------#
+ def getFile(self, unite=None, fic_origine=""):
+ # ---------------------------------------------#
+ # appele par I_JDC
+ ulfile = None
+ jdcText = ""
+
+ titre = ""
+
+ if unite:
+ titre = tr("Choix unite %d ", unite)
+ texte = (
+ tr("Le fichier %s contient une commande INCLUDE \n", str(fic_origine))
+ + "\n"
+ )
+ texte = (
+ texte
+ + tr("Donnez le nom du fichier correspondant a l unite logique ")
+ + repr(unite)
+ )
+ labeltexte = tr("Fichier pour unite ") + repr(unite)
+ else:
+ titre = tr("Choix d'un fichier de poursuite")
+ texte = tr("Le fichier %s contient une commande POURSUITE\n", fic_origine)
+ texte = texte + tr(
+ "Donnez le nom du fichier dont vous \n voulez faire une poursuite"
+ )
+
+ QMessageBox.information(self, titre, texte)
+ fn = QFileDialog.getOpenFileName(
+ self.appliEficas, titre, self.appliEficas.maConfiguration.savedir
+ )
+
+ # ce retour est impose par le getFile d'I_JDC
+ if fn == "":
+ return None, " "
+ if not fn:
+ return (0, " ")
+ fn = fn[0]
+
+ ulfile = os.path.abspath(fn)
+ self.appliEficas.maConfiguration.savedir = os.path.split(ulfile)[0]
+
+ # On utilise le convertisseur defini par formatFichierIn
+ source = self.getSource(ulfile)
+ if source:
+ # On a reussia convertir le fichier self.ulfile
+ jdcText = source
+ else:
+ # Une erreur a ete rencontree
+ jdcText = ""
+ return ulfile, jdcText
+
+ # -----------------------------------#
+ def updateJdc(self, etape, texte):
+ # ------------------------------------#
+ # ajoute une etape de JdC a partir d un texte
+ CONTEXT.setCurrentStep(etape)
+ etape.buildIncludeEtape(texte)
+ if not (etape.text_included_converted):
+ QMessageBox.information(
+ self, tr("Impossible d importer le texte"), etape.text_included_error
+ )
+
+ self.tree.racine.buildChildren()
+
+ # -----------------------------------#
+ def updateJdcEtape(self, itemApres, texte):
+ # ------------------------------------#
+ # ajoute une etape de JdC a partir d un texte
+ monItem = itemApres
+ etape = monItem.item.object
+
+ CONTEXT.setCurrentStep(etape)
+ try:
+ ok = etape.buildIncludeEtape(texte)
+ except:
+ ok = 0
+ if not ok:
+ QMessageBox.information(
+ self, tr("Import texte"), tr("Impossible d importer le texte")
+ )
+ self.tree.racine.buildChildren()
+ return ok
+
+ # -------------------------------------------#
+ def updateJdcAfterEtape(self, etape, texte):
+ # --------------------------------------------#
+ # ajoute une etape de JdC a partir d un texte
+ CONTEXT.setCurrentStep(etape)
+ try:
+ ok = etape.buildIncludeEtape(texte, doitEtreValide=0)
+ except:
+ ok = 0
+ if not ok:
+ QMessageBox.information(
+ self, tr("Import texte"), tr("Impossible d importer le texte")
+ )
+ self.tree.racine.buildChildren()
+ return ok
+
+ # -------------------------------------#
+ def deleteEtape(self, etape):
+ # -------------------------------------#
+ # dans le JDC
+ self.jdc.suppEntite(etape)
+
+ # -----------------------------------------
+ def initSplitterSizes(self, nbWidget=3):
+ # -----------------------------------------
+ # print ("je passe ds initSplitterSizes", nbWidget)
+
+ if self.code in ["Adao", "ADAO", "MAP"]:
+ self.splitterSizes3 = [1, 1550, 300]
+ # elif self.code in [ 'MAP'] : self.splitterSizes3=[700,300]
+ else:
+ self.splitterSizes3 = [150, 1000, 300]
+
+ if self.code in ["Adao", "ADAO", "MAP"]:
+ self.splitterSizes2 = [5, 1500]
+ else:
+ self.splitterSizes2 = [300, 1000]
+
+ # -----------------------------------------
+ def restoreSplitterSizes(self, nbWidget=3):
+ # ----------------------------------------
+
+ # traceback.print_stack()
+ # print ("je passe ds restoreSplitterSizes")
+ if not (hasattr(self, "splitter")):
+ return
+ if nbWidget == 2:
+ newSizes = self.splitterSizes2
+ if nbWidget == 3:
+ newSizes = self.splitterSizes3
+ # self.inhibeSplitter = 1
+ # print (newSizes)
+ self.splitter.setSizes(newSizes)
+ # self.inhibeSplitter = 0
+ QApplication.processEvents()
+ # seule la fentetre du milieu est necessaire
+ self.splitter.widget(1).resizeEvent = self.saveSplitterSizes
+
+ # -----------------------------------------
+ def saveSplitterSizes(self, event):
+ # -----------------------------------------
+ # print ("je passe ds saveSplitterSizes")
+ if self.inhibeSplitter:
+ return
+ if self.widgetOptionnel == None:
+ self.splitterSizes2 = self.splitter.sizes()[0:2]
+ else:
+ self.splitterSizes3 = self.splitter.sizes()[0:3]
+
+ # ------------------------
+ def fermeOptionnel(self):
+ # ------------------------
+ if self.widgetOptionnel == None:
+ return
+
+ self.inhibeSplitter = 1
+ self.widgetOptionnel.setParent(None)
+ self.widgetOptionnel.close()
+ self.widgetOptionnel.deleteLater()
+ self.widgetOptionnel = None
+ self.inhibeSplitter = 0
+ self.restoreSplitterSizes(2)
+
+ # ------------------------
+ def ajoutOptionnel(self):
+ # ------------------------
+ # if len(self.splitterSizes) == 2 : self.splitterSizes.append(self.oldSizeWidgetOptionnel)
+ # else : self.splitterSizes[2] = self.oldSizeWidgetOptionnel # ceinture pour les close bizarres
+ # self.splitterSizes[1] = self.splitterSizes[1] - self.splitterSizes[2]
+
+ self.restoreSplitterSizes(3)
+
+ # ------------------------
+ def fermeArbre(self):
+ # ------------------------
+ # print (self.widgetTree)
+ self.oldWidgetTree = self.widgetTree
+ self.widgetTree.hide()
+ # self.widgetTree=None
+
+ # ------------------------
+ def ouvreArbre(self):
+ # ------------------------
+ # print ('je passe la')
+ # print (self.widgetTree)
+ # self.widgetTree=self.oldWidgetTree
+ self.widgetTree.show()
+ # self.restoreSplitterSizes(3)
+
+ # -----------------------
+ def getEtapeCourante(self):
+ # -----------------------
+ if len(self.tree.selectedItems()) != 1:
+ return None
+ etape = self.tree.selectedItems()[0].item.object.getEtape()
+ return etape
+
+ # -----------------------------
+ def getTreeIndex(self, noeud):
+ # ----------------------------
+ indexNoeud = -1
+ if noeud in noeud.treeParent.children:
+ indexNoeud = noeud.treeParent.children.index(noeud)
+ else:
+ if hasattr(noeud, "vraiParent"):
+ noeudVrai = noeud
+ noeudVraiParent = noeud.vraiParent
+ while noeudVraiParent != noeud.treeParent and hasattr(
+ noeudVraiParent, "vraiParent"
+ ):
+ noeudVrai = noeudVraiParent
+ noeudVraiParent = noeudVraiParent.vraiParent
+ pass
+ if noeudVraiParent == noeud.treeParent:
+ indexNoeud = noeud.treeParent.children.index(noeudVrai)
+ pass
+ pass
+ pass
+ return indexNoeud
+
+ # -------------------# Pour execution avec output et error dans le bash
+ def runPSEN(self):
+ # -------------------#
+
+ # if self.modified or self.fichier==None : self.saveFile()
+ self.saveFile()
+
+ # lancement avec le .bat
+ path1 = os.path.abspath(
+ os.path.join(os.path.abspath(__file__), "../", "../", "PSEN_Eficas", "PSEN")
+ )
+ WrapperFilePath = os.path.join(path1, "PSSEWrapper.py")
+ import subprocess
+
+ p = subprocess.Popen(["python", WrapperFilePath])
+ (out, err) = p.communicate()
+ print(out)
+ print(err)
+
+ # -------------------# Pour execution avec output et error dans le bash
+ def runPSEN_N1(self):
+ # -------------------#
+
+ self.saveFile()
+ path1 = os.path.abspath(
+ os.path.join(
+ os.path.abspath(__file__),
+ "../",
+ "../",
+ "ProcessOutputs_Eficas",
+ "TreatOutputs",
+ )
+ )
+ sys.path.append(path1)
+
+ if not (self.jdc.isValid()):
+ QMessageBox.information(
+ self, tr("Unvalid JDC"), tr("incorrect keywords will be ignored")
+ )
+ if "dicoImbrique" in generator.plugins:
+ self.generator = generator.plugins["dicoImbrique"]()
+ jdc_formate = self.generator.gener(self.jdc)
+ dico = self.generator.Dico
+
+ ###to delete
+ # fileDico = r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
+ fileDico = os.path.join(
+ path1, "dicoN1.py"
+ ) # r'C:\Logiciels DER\PSEN_V16\Code\ProcessOutputs_Eficas\TreatOutputs\dicoN1.py'
+ f = open(str(fileDico), "w")
+ f.write("Dico =" + str(dico))
+ f.close()
+ ###
+
+ print("in runPSEN_N1", dico)
+ print(dico)
+ from Run import run
+
+ run(dico)
+ # res,txt_exception=run(dico)
+ # if res : QMessageBox.information( self, tr("fin de script run"), txt_exception)
+ # else : QMessageBox.critical( self, tr("Erreur fatale script run"), txt_exception)
+
+ # -------------------# Pour execution avec output et error dans le bash
+ def process_N1(self):
+ # -------------------#
+
+ path1 = os.path.abspath(
+ os.path.join(
+ os.path.abspath(__file__),
+ "../",
+ "../",
+ "ProcessOutputs_Eficas",
+ "TreatOutputs",
+ )
+ )
+ sys.path.append(path1)
+
+ if "dicoImbrique" in generator.plugins:
+ self.generator = generator.plugins["dicoImbrique"]()
+ jdc_formate = self.generator.gener(self.jdc)
+ dico = self.getDico() # generator.Dico
+
+ for k in dico["CONTINGENCY_PROCESSING"]:
+ # print (k)
+ if (
+ k[0:19] == "Component_List_For_"
+ or k[0:21] == "Contingency_List_For_"
+ ):
+ newK = k.replace("__", " ")
+ l = "'" + str(newK) + "'"
+ dico["CONTINGENCY_PROCESSING"][l] = dico["CONTINGENCY_PROCESSING"][
+ k
+ ]
+ del dico["CONTINGENCY_PROCESSING"][k]
+
+ ###to delete
+ fileDico = os.path.join(path1, "dicoN1_process.py")
+ f = open(str(fileDico), "w")
+ f.write("Dico =" + str(dico))
+ f.close()
+ ###
+ return dico
+
+ # return self.getDico()
+
+ # -------------------# Pour execution avec output et error dans le bash
+ def process_VP(self):
+ # -------------------#
+ if "dicoImbrique" in generator.plugins:
+ self.generator = generator.plugins["dicoImbrique"]()
+ jdc_formate = self.generator.gener(self.jdc)
+ dico = self.getDico() # generator.Dico
+ return dico
+
+
+if __name__ == "__main__":
+ print("in main")
diff --git a/InterfaceGUI/QT5/feuille.py b/InterfaceGUI/QT5/feuille.py
new file mode 100644
index 00000000..104e8266
--- /dev/null
+++ b/InterfaceGUI/QT5/feuille.py
@@ -0,0 +1,397 @@
+# -*- 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
+#
+# Modules Python
+
+import types, os
+import traceback
+
+from PyQt5.QtWidgets import QToolButton, QWidget, QMessageBox
+from PyQt5.QtGui import QFont, QFontMetrics, QFontInfo, QPalette
+from PyQt5.QtCore import Qt
+
+from Extensions.i18n import tr
+
+from .gereIcones import ContientIcones
+from .gereIcones import FacultatifOuOptionnel
+from .qtSaisie import SaisieValeur
+
+nomMax = 230
+
+
+# empirique les metrics ne fonctionnent pas
+# ---------------------------------------------------------------------- #
+class Feuille(QWidget, ContientIcones, SaisieValeur, FacultatifOuOptionnel):
+ # --------------------------------------------------------------------- #
+
+ def __init__(self, node, monSimpDef, nom, objSimp, parentQt, commande):
+ # print ("Feuille", monSimpDef,nom,objSimp)
+ QWidget.__init__(self, None)
+ self.node = node
+ self.node.fenetre = self
+
+ # on se positionne pour les icones
+ # os.chdir(os.path.abspath(os.path.join(os.path.dirname(__file__))))
+ self.setupUi(self)
+ self.prendLeFocus = 0
+
+ # maPolice= QFont("Times", 10)
+ # self.setFont(maPolice)
+ # self.setFocusPolicy(Qt.StrongFocus)
+
+ self.parentQt = parentQt
+ self.editor = self.node.editor
+ self.appliEficas = self.editor.appliEficas
+ self.repIcon = self.appliEficas.repIcon
+ self.monSimpDef = monSimpDef
+ self.nom = nom
+ self.objSimp = objSimp
+ self.node.fenetre = self
+ self.maCommande = commande
+
+ self.aRedimensionner = 0
+ self.setSuggestion()
+ self.setValeurs()
+ self.setNom()
+ self.setValide()
+ self.setIconePoubelle()
+ self.setIconesFichier()
+ self.setIconesSalome()
+ self.setIconesGenerales()
+ self.setCommentaire()
+ self.setZoneInfo()
+ self.setUnite()
+ # inhibition incertitude
+ self.inhibeSignal = False
+ self.setUQ()
+
+ def setUnite(self):
+ if self.monSimpDef.unite == None:
+ if hasattr(self, "lineEditUnite"):
+ self.lineEditUnite.setText(" ")
+ else:
+ if hasattr(self, "lineEditUnite"):
+ self.lineEditUnite.setText(self.monSimpDef.unite)
+ else:
+ self.editor.informe(
+ "Erreur de Catalogue",
+ "Champ Unite non prevu pour "
+ + self.nom
+ + " correction du catalogue souhaitable, prevenez la maintenance",
+ False,
+ )
+
+ def setUQ(self):
+ if not (self.editor.appliEficas.maConfiguration.afficheUQ) and hasattr(
+ self, "checkBoxUQ"
+ ):
+ self.checkBoxUQ.close()
+ return
+ if not self.objSimp.UQPossible() and hasattr(self, "checkBoxUQ"):
+ self.checkBoxUQ.close()
+ return
+ if not self.objSimp.UQPossible():
+ return
+ if hasattr(self, "checkBoxUQ"):
+ if self.objSimp.isUQActivate():
+ self.checkBoxUQ.setChecked(True)
+ else:
+ self.checkBoxUQ.setChecked(False)
+ self.checkBoxUQ.toggled.connect(self.setEnabledUQ)
+
+ def setEnabledUQ(self):
+ if self.inhibeSignal:
+ self.inhibeSignal = False
+ return
+ if self.checkBoxUQ.isChecked():
+ if self.objSimp.etape.nature == "OPERATEUR" and not (self.objSimp.etape.sd):
+ QMessageBox.warning(
+ self,
+ tr("Attention"),
+ tr(
+ "Il faut d abord nommer "
+ + self.objSimp.etape.nom
+ + " avant de pourvoir choisir des variables incertaines"
+ ),
+ )
+ self.inhibeSignal = True
+ self.checkBoxUQ.setCheckState(False)
+ return
+ self.objSimp.lieVariableUQ()
+ else:
+ ret = self.objSimp.delieVariableUQ()
+ if not ret:
+ QMessageBox.warning(
+ self,
+ tr("Variable associée non trouvée "),
+ tr("prevenez la maintenance"),
+ )
+ else:
+ etape = self.objSimp.getJdcRoot().getEtapesByName(
+ "ExpressionIncertitude"
+ )[0]
+ etape.node.buildChildren()
+
+ def setNom(self):
+ self.debutToolTip = ""
+ nomTraduit = tr(self.objSimp.nom)
+ # metrix= QFontMetrics(self.label.font())
+ # maxLongueur = self.label.width() - 2
+ # print ('______________________')
+ # print (nomTraduit)
+ # print (self.label.font().pixelSize())
+ # longueur2 = metrix.boundingRect(nomTraduit).width()
+ longueur = QFontMetrics(self.label.font()).width(nomTraduit)
+ if longueur >= nomMax:
+ nouveauNom = self.formate(nomTraduit)
+ self.label.setText(nouveauNom)
+ else:
+ self.label.setText(nomTraduit)
+ # clidedText = metrics.elidedText(text, Qt.ElideRight, label.width());
+ # if (clippedText != nomTraduit): self.label.setToolTip(nomTraduit)
+ # self.label.setText(clippedText)
+
+ # def agrandit(self):
+ # inutile pour certains widgets
+ # if self.height() < 40 :
+ # self.setMinimumHeight(50)
+ # self.resize(self.width(),200)
+
+ # def mousePressEvent(self, event):
+ # print 'mousePressEvent'
+ # import inspect
+ # print (inspect.getmro(self.__class__))
+ # self.__class__.mousePressEvent(self, event)
+
+ def setValeurs(self):
+ # print "passe dans setValeurs pour ", self.objSimp.nom
+ # print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+ pass
+
+ def finCommentaire(self):
+ return ""
+
+ def finCommentaireListe(self):
+ commentaire = ""
+ mc = self.node.item.get_definition()
+ d_aides = {
+ "TXM": "chaines de caracteres",
+ "R": "reels",
+ "I": "entiers",
+ "C": "complexes",
+ }
+ type = mc.type[0]
+ if not type in d_aides:
+ if mc.min == mc.max:
+ commentaire = tr("Entrez ") + str(mc.min) + tr(" valeurs ") + "\n"
+ else:
+ if mc.max != "**":
+ commentaire = (
+ tr("entre ")
+ + str(mc.min)
+ + tr(" et ")
+ + str(mc.max)
+ + tr(" valeurs ")
+ + "\n"
+ )
+ else:
+ commentaire = ""
+ else:
+ if mc.min == mc.max:
+ commentaire = (
+ tr("Entrez ") + str(mc.min) + " " + tr(d_aides[type]) + "\n"
+ )
+ elif mc.max == float("inf"):
+ commentaire = (
+ tr("Entrez une liste de ") + " " + tr(d_aides[type]) + "\n"
+ )
+ else:
+ commentaire = (
+ tr("Entrez entre ")
+ + "\n"
+ + str(mc.min)
+ + (" et ")
+ + str(mc.max)
+ + " "
+ + tr(d_aides[type])
+ + "\n"
+ )
+ aideval = self.node.item.aide()
+ commentaire = commentaire + tr(aideval)
+ return str(commentaire)
+
+ def setSuggestion(self):
+ if self.monSimpDef.getSug() != None and self.monSimpDef.getSug() != "":
+ suggere = (
+ str('suggestion : ')
+ + str(self.monSimpDef.getSug())
+ + "
"
+ )
+ if hasattr(self, "lineEditVal"):
+ self.lineEditVal.setToolTip(suggere)
+
+ def setCommentaire(self):
+ c = self.debutToolTip
+ # if self.node.item.definition.validators : c+=self.node.item.definition.validators.aide()
+ self.aide = c
+ if self.objSimp.getFr() != None and self.objSimp.getFr() != "":
+ # c2 = '