--- /dev/null
+chgt de label_user
+label_integrateur
+chgt de editeur.ini
from builtins import object
import types, os, sys
from copy import copy, deepcopy
+from uuid import uuid1
# import du chargeur de composants
-from .comploader import makeObjecttreeitem
+from Editeur.comploader import makeObjecttreeitem
from Ihm import CONNECTOR
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
self.sublist = []
self.init()
+
+ # La partie suivante ne sert que pour le Web
+ # on met le meme id au noeud et a l objet
+ # a priori inutile sauf pour les MCList
+ if hasattr(object, "idUnique"):
+ self.idUnique = object.idUnique
+ else:
+ self.idUnique = uuid1().hex
+
+ if self._object.nature == "MCList" and len(self._object.data) == 1:
+ # pour les suppressions on met le meme id a l objet et a la lis
+ self._object.data[0].idUnique = self.idUnique
+ self._object.idUnique = self._object.data[0].idUnique
+ if hasattr(self.appliEficas, "dicoIdNode"):
+ self.appliEficas.dicoIdNode[self._object.data[0].idUnique] = self
+ self.idUnique = 0
+ return
+
+ self._object.idUnique = self.idUnique
+ if hasattr(self.appliEficas, "dicoIdNode") and self.idUnique:
+ self.appliEficas.dicoIdNode[self.idUnique] = self
+
def init(self):
return
"""
debug = 0
ici=os.path.dirname(os.path.abspath(__file__))
+ print (GUIPath)
repertoire = os.path.join(ici,"..", "InterfaceGUI",GUIPath)
if debug : print ('repertoire', repertoire)
package = 'InterfaceGUI.'+GUIPath
return
from Editeur import session
- import sys
-
options = session.parse(sys.argv)
if options.code != None:
code = options.code
def getEficasSsIhm( code=None, multi=False, langue="en", ssCode=None, labelCode=None,
- forceXML=False, genereXSD=False, fichierCata=None,):
+ forceXML=False, genereXSD=False, fichierCata=None,GUIPath=None, salome = False):
# -----------------------------------------------------------------------------------
"""
instancie l'appli EFICAS sans Ihm
"""
- from Editeur import session
+ from Editeur import session
options = session.parse(sys.argv)
if options.code != None:
code = options.code
- if forceXML:
- options.withXSD = True
+ if forceXML: options.withXSD = True
- from InterfaceQT4.qtEficasSsIhm import AppliSsIhm
+ if GUIPath in ('QT5', 'cinqC', 'Web') :
+ pathAbso=os.path.abspath(os.path.join(os.path.dirname(__file__),'..','InterfaceGUI',GUIPath))
+ if pathAbso not in sys.path : sys.path.insert(0,pathAbso)
- Eficas = AppliSsIhm( code=code, salome=0, multi=multi, langue=langue,
- ssCode=ssCode, labelCode=labelCode, genereXSD=genereXSD, fichierCata=fichierCata,)
+ from InterfaceGUI.appliSsIhm import AppliSsIhm
+ Eficas = AppliSsIhm( code=code, salome=salome, multi=multi, langue=langue,
+ ssCode=ssCode, labelCode=labelCode, genereXSD=genereXSD, fichierCata=fichierCata)
return Eficas
from Extensions.eficas_exception import EficasException
-import Noyau
-
# Modules Eficas
from . import I_OBJECT
from Noyau.N_ASSD import ASSD
def getNomDsXML(self):
return self.parent.getNomDsXML()
- def getMCPath(self):
- return self.parent.getMCPath()
+ def getDicoForFancy(self):
+ listeNodes = []
+ for obj in self.mcListe:
+ lesNodes = obj.getDicoForFancy()
+ if not (isinstance(lesNodes, list)):
+ listeNodes.append(lesNodes)
+ else:
+ for leNode in lesNodes:
+ listeNodes.append(leNode)
+ return listeNodes
+
+ def getParentsJusqua(self, jusqua):
+ listeDesParents = []
+ aTraiter = self
+ while aTraiter != jusqua.getObject():
+ listeDesParents.append(aTraiter.parent)
+ aTraiter = aTraiter.parent
+ return listeDesParents
liste.remove(k)
return liste
+ def calculOptionnel(self):
+ self.listeMc = []
+ self.listeMcRegle = []
+ self.dictToolTipMc = {}
+ genea = self.getGenealogie()
+ # Attention : les mots clefs listes (+sieurs fact )
+ # n ont pas toutes ces methodes. a priori pas appele mais
+ if self.nature != "MCLIST":
+ self.listeMc = self.getListeMcOrdonnee(genea, self.jdc.cata_ordonne_dico)
+ listeNomsPresents = self.dictMcPresents()
+ for regle in self.getRegles():
+ (monToolTip, regleOk) = regle.verif(listeNomsPresents)
+ if regleOk:
+ continue
+ for mc in regle.mcs:
+ self.listeMcRegle.append(mc)
+ self.dictToolTipMc[mc] = monToolTip
+ return (self.listeMc, self.listeMcRegle, self.dictToolTipMc)
+
+ def calculOptionnelInclutBlocs(self):
+ debug = 0
+ if debug:
+ print("-------------- calculOptionnelInclutBlocs", self.nom)
+ self.dictMCVenantDesBlocs = {}
+ liste, listeRouge, dictToolTipMc = self.calculOptionnel()
+ dictNomsPresents = self.dictMcPresents()
+ for mc in liste:
+ self.dictMCVenantDesBlocs[mc] = self
+ for mc in self.listeMcPresents():
+ obj = dictNomsPresents[mc]
+ if obj.nature != "MCBLOC":
+ continue
+ if debug:
+ print(mc, "est present")
+ (l, lr, d) = obj.calculOptionnelInclutBlocs()
+ # print ('optionnels', l)
+ liste = liste + l
+ listeRouge = listeRouge + lr
+ for k in d:
+ dicToolTipMC[k] = d[k]
+ for k, v in obj.dictMCVenantDesBlocs.items():
+ self.dictMCVenantDesBlocs[k] = v
+
+ if debug:
+ print("ccOptio", self.nom, self.dictMCVenantDesBlocs)
+ if debug:
+ print("fin calculOPtionnel", self.nom, "_____________")
+ return (liste, listeRouge, dictToolTipMc)
def listeMcPresents(self):
"""
Retourne la liste des noms des mots-cles fils de self presents construite
Retourne 1 si le mot-cle facteur self peut etre repete
Retourne 0 dans le cas contraire
"""
- if self.definition.max > 1:
- # marche avec '**'
+ objet = self.parent.getChild(self.nom)
+ lenDejaLa = len(objet)
+ if self.definition.max > 1 and lenDejaLa < self.definition.max:
return 1
else:
return 0
def isOblig(self):
- if self.definition.statut != "o":
+ if self.definition.statut != "f":
return 0
objet = self.parent.getChild(self.nom)
- if len(objet) > 1:
+ if len(objet) > self.definition.min:
return 0
else:
return 1
nomDsXML = self.parent.getNomDsXML() + "." + nom
return nomDsXML
+ def getStatutEtRepetable(self):
+ """
+ Retourne l index du MCFACT ds la MCList
+ """
+ objet = self.parent.getChild(self.nom, restreint="oui")
+ if len(objet) > 1:
+ index = objet.getIndex(self) + 1
+ else:
+ index = 1
+ if self.definition.max > index:
+ repetable = 1
+ else:
+ repetable = 0
+ if self.definition.min < index or self.definition.statut == "f":
+ statut = "f"
+ else:
+ statut = "o"
+ return (statut, repetable)
+
def getLabelText(self):
"""
Retourne le label de self suivant qu'il s'agit d'un MCFACT
def supprime(self):
self.alt_parent = None
N_MCFACT.MCFACT.supprime(self)
+
+ def getDicoForFancy(self):
+ # print ('MCFACT getDicoForFancy ')
+ monDico = {}
+ leNom = self.nom
+
+ leNom = self.getLabelText()
+ monDico["statut"] = self.definition.statut
+ monDico["nomCommande"] = self.nom
+ if self.state == "undetermined":
+ self.isValid()
+
+ monDico["title"] = leNom
+ monDico["key"] = self.idUnique
+ monDico["classeAccas"] = self.nature
+ monDico["validite"] = self.getValid()
+ if not (monDico["validite"]):
+ monDico["validite"] = 0
+
+ (statut, repetable) = self.getStatutEtRepetable()
+ monDico["statut"] = statut
+ monDico["repetable"] = repetable
+ if monDico["validite"] == 0 and monDico["statut"] == "f":
+ monDico["validite"] = 2
+
+ listeNodes = []
+ for obj in self.mcListe:
+ lesNodes = obj.getDicoForFancy()
+ if not (isinstance(lesNodes, list)):
+ listeNodes.append(lesNodes)
+ else:
+ for leNode in lesNodes:
+ listeNodes.append(leNode)
+ monDico["children"] = listeNodes
+ if self.nature != "MCSIMP" and self.nature != "MCLIST":
+ monDico["infoOptionnels"] = self.calculOptionnelInclutBlocs()
+ return monDico
else:
return 0
+ def getDicoObjetsCompletsPourTree(self):
+ # print ('MCList getDicoObjetsCompletsPourTree pour ', self)
+ listeDict = []
+ for i in self.data:
+ listeDict.append(i.getDicoObjetsCompletsPourTree())
+ return listeDict
+
+ def getDicoForFancy(self):
+ listeDict = []
+ nbFactDejaLa = len(self.data)
+ for i in self.data:
+ dico = i.getDicoForFancy()
+ if nbFactDejaLa > i.definition.min:
+ dico["statut"] = "f"
+ if nbFactDejaLa < i.definition.max:
+ dico["repetable"] = 1
+ else:
+ dico["repetable"] = 0
+ listeDict.append(dico)
+ return listeDict
def isOblig(self):
"""
Une MCList n'est jamais obligatoire (meme si le MCFACT qu'elle represente l'est
if not self.ajoutPossible():
self.jdc.editor.afficheAlerte(
- tr("Erreur"), tr("L'objet %s ne peut pas etre ajoute", obj.nom)
+ tr("Erreur"), tr("L'objet {} ne peut pas etre ajoute").format(obj.nom)
)
return None
def updateConcept(self, sd):
for child in self.data:
child.updateConcept(sd)
+ def demandeUpdateOptionnels(self):
+ for child in self.data:
+ child.demandeUpdateOptionnels()
def deleteRef(self):
for child in self.data:
"""Met a jour les blocs conditionnels dependant du mot cle simple self"""
if self.definition.position == "global":
self.etape.deepUpdateConditionBloc()
+ self.etape.demandeUpdateOptionnels()
elif self.definition.position == "reCalculeEtape":
# print ('je passe par updateConditionBloc pour ', self.nom)
self.etape.deepUpdateConditionBloc()
else:
self.parent.updateConditionBloc()
+ def demandeUpdateOptionnels(self):
+ pass
def setValeur(self, new_valeur, evaluation="oui"):
self.initModif()
self.valeur = new_valeur
return valeur
else:
try:
- valeur = eval(val)
+ valeur = eval(new_valeur)
return valeur
except:
# traceback.print_exc()
def supprimeUserAssd(self):
pass
+ def getDicoForFancy(self):
+ # print ('OBJECT getDicoForFancy ',self, self.nature)
+ monDico = {}
+ leNom = self.nom
+
+ if self.nature == "MCFACT":
+ leNom = self.getLabelText()
+ monDico["statut"] = self.definition.statut
+ monDico["nomCommande"] = self.nom
+
+ if self.nature == "MCLIST":
+ monDico["validite"] = 0
+ elif self.nature == "MCBLOC":
+ monDico["validite"] = 0
+ else:
+ monDico["validite"] = self.getValid()
+ if monDico["validite"] == None:
+ monDico["validite"] = 0
+
+ if self.nature == "OPERATEUR" or self.nature == "PROCEDURE":
+ monDico["statut"] = "f"
+ if self.nature == "OPERATEUR":
+ if hasattr(self, "sdnom") and self.sdnom != "sansnom":
+ monDico["sdnom"] = self.sdnom
+ else:
+ monDico["sdnom"] = ""
+ if monDico["validite"] == 0:
+ monDico["validite"] = 2
+ monDico["title"] = leNom
+ monDico["key"] = self.idUnique
+ monDico["classeAccas"] = self.nature
+
+ listeNodes = []
+ # Cas d un fichier vide
+ if not hasattr(self, "mcListe"):
+ self.mcListe = []
+ for obj in self.mcListe:
+ lesNodes = obj.getDicoForFancy()
+ if not (isinstance(lesNodes, list)):
+ listeNodes.append(lesNodes)
+ else:
+ for leNode in lesNodes:
+ listeNodes.append(leNode)
+ monDico["children"] = listeNodes
+ print (self.nature)
+ if self.nature != "MCSIMP" and self.nature != "MCLIST" and self.nature != "JDC":
+ monDico["infoOptionnels"] = self.calculOptionnelInclutBlocs()
+ return monDico
+
+ def getNomClassWeb(self):
+ # code mort
+ laClasse = self.nature
+ if self.isValid():
+ laClasse += "Valide"
+ else:
+ laClasse += "NonValide"
+ return laClasse
+
+ def demandeUpdateOptionnels(self):
+ CONNECTOR.Emit(self, "demandeUpdateOptionnels")
+ for mc in self.mcListe:
+ mc.demandeUpdateOptionnels()
def demandeRedessine(self):
# print ('demandeRedessine pour', self.nom, self, tout)
CONNECTOR.Emit(self, "redessine")
- def isUQActivate(self):
- # valide uniquement pour les MCSIMP
- return True
+ def getIndexDsParent(self):
+ return self.parent.mcListe.index(self)
class ErrorObj(OBJECT):
#self.commandesOrdreCatalogue = self.readercata.commandesOrdreCatalogue
+ #PN ??? probablement bug
if self.appliEficas.readercata.demandeCatalogue == True:
nomFichierTranslation = (
"translatorFichier" + "_" + str(self.appliEficas.readercata.labelCode)
# ----------------------------------------------#
def afficheInfos(self, message, couleur=Qt.black):
# ----------------------------------------------#
- if couleur == "red":
- couleur = Qt.red
+ if couleur == "red": couleur = Qt.red
if self.sb:
mapalette = self.sb.palette()
mapalette.setColor(QPalette.WindowText, couleur)
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetCB import Ui_WidgetCB
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
from PyQt5.QtWidgets import QComboBox, QCompleter
from Extensions.i18n import tr
from InterfaceGUI.QT5.feuille import Feuille
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
from UiQT5.desWidgetCBIntoSug import Ui_WidgetCBIntoSug
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetCB import Ui_WidgetCB
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
# Notation scientifique
if test:
- from InterfaceGUI.QT5.politiquesValidation import Validation
-
+ from InterfaceGUI.politiquesValidation import Validation
validation = Validation(self.node, self.editor)
validation.ajoutDsDictReelEtape()
# Modules Eficas
from Extensions.i18n import tr
from InterfaceGUI.QT5.monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
-from InterfaceGUI.QT5.politiquesValidation import PolitiquePlusieurs
+from InterfaceGUI.politiquesValidation import PolitiquePlusieurs
from PyQt5.QtWidgets import QScrollBar
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetPlusieursBase import Ui_WidgetPlusieursBase
-from InterfaceGUI.QT5.politiquesValidation import PolitiquePlusieurs
+from InterfaceGUI.politiquesValidation import PolitiquePlusieurs
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
from InterfaceGUI.QT5.gereListe import GereListe
from InterfaceGUI.QT5.gereListe import GerePlie
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetPlusieursInto import Ui_WidgetPlusieursInto
-from InterfaceGUI.QT5.politiquesValidation import PolitiquePlusieurs
+from InterfaceGUI.politiquesValidation import PolitiquePlusieurs
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
from InterfaceGUI.QT5.gereListe import GerePlie
from InterfaceGUI.QT5.gereListe import GereListe
# Modules Eficas
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetPlusieursIntoOrdonne import Ui_WidgetPlusieursIntoOrdonne
-from InterfaceGUI.QT5.politiquesValidation import PolitiquePlusieurs
+from InterfaceGUI.politiquesValidation import PolitiquePlusieurs
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
from InterfaceGUI.QT5.gereListe import GereListe
from InterfaceGUI.QT5.gereListe import GerePlie
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetPlusieursPlie import Ui_WidgetPlusieursPlie
-from InterfaceGUI.QT5.politiquesValidation import PolitiquePlusieurs
+from InterfaceGUI.politiquesValidation import PolitiquePlusieurs
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
pattern_blanc = re.compile(r"^\s*$")
from Extensions.i18n import tr
from InterfaceGUI.QT5.feuille import Feuille
-from InterfaceGUI.QT5.politiquesValidation import PolitiquePlusieurs
+from InterfaceGUI.politiquesValidation import PolitiquePlusieurs
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
from InterfaceGUI.QT5.gereListe import GereListe
from InterfaceGUI.QT5.gereListe import LECustom
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetRadioButton import Ui_WidgetRadioButton
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetSDCOInto import Ui_WidgetSDCOInto
from InterfaceGUI.QT5.qtSaisie import SaisieSDCO
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
class MonWidgetSDCOInto(Ui_WidgetSDCOInto, Feuille, SaisieSDCO):
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetSimpBase import Ui_WidgetSimpBase
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetSimpBool import Ui_WidgetSimpBool
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetSimpComplexe import Ui_WidgetSimpComplexe
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
# Modules Eficas
from PyQt5.QtCore import QDate
from UiQT5.desWidgetDate import Ui_WidgetDate
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.feuille import Feuille
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetSimpSalome import Ui_WidgetSimpSalome
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
from Extensions.i18n import tr
from InterfaceGUI.QT5.feuille import Feuille
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.qtSaisie import SaisieValeur
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetUniqueSDCO import Ui_WidgetUniqueSDCO
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
from InterfaceGUI.QT5.qtSaisie import SaisieSDCO
from InterfaceGUI.QT5.feuille import Feuille
from UiQT5.desWidgetVide import Ui_WidgetVide
-from InterfaceGUI.QT5.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
class MonWidgetVide(Ui_WidgetVide, Feuille):
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-from Accas import PARAMETRE
-from Extensions.i18n import tr
-
-
-# ---------------------
-class Validation(object):
-# ---------------------
- def __init__(self, node, parent):
- self.node = node
- self.parent = parent
-
- def testeUneValeur(self, valeurentree):
- commentaire = None
- # import traceback
- # traceback.print_stack()
- valeur, validite = self.node.item.evalValeur(valeurentree)
- if not validite:
- commentaire = "impossible d'evaluer : %s " % repr(valeurentree)
- return valeur, validite, commentaire
- if self.node.item.waitTxm() and not (type(valeur) == str):
- valeur = str(valeur)
-
- testtype, commentaire = self.node.item.object.verifType(valeur)
- if not testtype:
- return valeur, 0, commentaire
-
- valide = self.node.item.valideItem(valeur)
- if type(valide) == tuple:
- validite, commentaire = valide
- else:
- validite = valide
- commentaire = " "
-
- if not validite and commentaire is None:
- commentaire = "impossible d'evaluer : %s " % repr(valeurentree)
- # print ('ds testeUneValeur', valeur, validite, commentaire)
- return valeur, validite, commentaire
-
- # ----------------------------------------------------------------------------------------
- # Methodes utilisees pour la manipulation des items en notation scientifique
- # a mettre au point
- # ----------------------------------------------------------------------------------------
- def setValeurTexte(self, texteValeur):
- try:
- if "R" in self.node.item.object.definition.type:
- if texteValeur[0] != "'":
- clef = eval(texteValeur)
- if str(clef) != str(texteValeur):
- self.node.item.object.initModif()
- clefobj = self.node.item.object.getNomConcept()
- if not clefobj in self.parent.appliEficas.dict_reels:
- self.parent.appliEficas.dict_reels[clefobj] = {}
- self.parent.appliEficas.dict_reels[clefobj][clef] = texteValeur
- self.parent.appliEficas.dict_reels[clefobj]
- if clefobj == "":
- if (
- not self.node.item.object.etape
- in self.parent.appliEficas.dict_reels
- ):
- self.parent.appliEficas.dict_reels[
- self.node.item.object.etape
- ] = {}
- self.parent.appliEficas.dict_reels[
- self.node.item.object.etape
- ][clef] = texteValeur
- self.node.item.object.finModif()
- except:
- pass
-
- def getValeurTexte(self, valeur):
- valeurTexte = valeur
- if valeur == None:
- return valeur
- from decimal import Decimal
-
- if isinstance(valeur, Decimal):
- if self.node.waitTxm() and not self.isParam(valeur):
- return "'" + str(valeur) + "'"
- else:
- return valeur
- if "R" in self.node.item.object.definition.type:
- clefobj = self.node.item.object.getNomConcept()
- if clefobj in self.parent.appliEficas.dict_reels:
- if valeur in self.parent.appliEficas.dict_reels[clefobj]:
- valeurTexte = self.parent.appliEficas.dict_reels[clefobj][valeur]
- else:
- if (
- str(valeur).find(".") == -1
- and str(valeur).find("e") == -1
- and str(valeur).find("E")
- ):
- # aucun '.' n'a ete trouve dans valeur --> on en rajoute un a la fin
- if self.isParam(valeur):
- return valeur
- else:
- try:
- val2 = eval(str(valeur) + ".")
- except:
- pass
- return valeurTexte
-
- def isParam(self, valeur):
- for param in self.node.item.jdc.params:
- if (repr(param) == repr(valeur)) or (str(param) == str(valeur)):
- return 1
- return 0
-
- def ajoutDsDictReel(self, texteValeur):
- # le try except est necessaire pour saisir les parametres
- # on enleve l erreur de saisie 00 pour 0
- if str(texteValeur) == "00":
- return
- try:
- if "R" in self.node.item.object.definition.type:
- if str(texteValeur)[0] != "'":
- clef = eval(texteValeur)
- if str(clef) != str(texteValeur):
- clefobj = self.node.item.object.getNomConcept()
- if not clefobj in self.parent.appliEficas:
- self.parent.appliEficas.dict_reels[clefobj] = {}
- self.parent.appliEficas.dict_reels[clefobj][clef] = texteValeur
- if clefobj == "":
- if (
- not self.node.item.object.etape
- in self.parent.appliEficas.dict_reels
- ):
- self.parent.appliEficas.dict_reels[
- self.node.item.object.etape
- ] = {}
- self.parent.appliEficas.dict_reels[
- self.node.item.object.etape
- ][clef] = texteValeur
-
- except:
- pass
-
- def ajoutDsDictReelEtape(self):
- try:
- if self.node.item.object in self.parent.appliEficas.dict_reels:
- self.parent.appliEficas.dict_reels[
- self.node.item.sdnom
- ] = self.parent.appliEficas.dict_reels[self.node.item.object]
- del self.parent.appliEficas.dict_reels[self.node.item.object]
- except:
- pass
-
-
-# ------------------------------------
-class PolitiqueUnique(Validation):
- # ------------------------------------
- """
- classe servant pour les entrees ne demandant qu un mot clef
- """
-
- def __init__(self, node, parent):
- Validation.__init__(self, node, parent)
-
- def recordValeur(self, valeurentree):
- if self.parent.modified == "n":
- self.parent.initModif()
- ancienneVal = self.node.item.getValeur()
- valeur, validite, commentaire = self.testeUneValeur(valeurentree)
- if (
- validite
- and ("R" in self.node.item.object.definition.type)
- and not (isinstance(valeur, PARAMETRE))
- ):
- s = valeurentree
- if s.find(".") == -1 and s.find("e") == -1 and s.find("E") == -1:
- s = s + "."
- valeur, validite, commentaire = self.testeUneValeur(s)
- if validite:
- validite = self.node.item.setValeur(valeur)
- if self.node.item.isValid():
- commentaire = tr("Valeur du mot-cle enregistree")
- # commentaire = "Valeur du mot-cle enregistree"
- self.setValeurTexte(str(valeurentree))
- else:
- cr = self.node.item.getCr()
- commentaire = tr("Valeur du mot-cle non autorisee ") + cr.getMessFatal()
- self.node.item.setValeur(ancienneVal)
- return validite, commentaire
-
-
-# --------------------------------------
-class PolitiquePlusieurs(Validation):
- # --------------------------------------
- """
- classe servant pour les entrees ne demandant qu un mot clef
- """
-
- def __init__(self, node, parent):
- # print "ds PolitiquePlusieurs"
- self.node = node
- self.parent = parent
- # print self.node
- # print self.parent
-
- def ajoutValeurs(self, listevaleur, index, listecourante):
- listeRetour = []
- commentaire = "Nouvelle valeur acceptee"
- commentaire2 = ""
- valide = 1
- if listevaleur == None:
- return
- if listevaleur == "":
- return
- if not (type(listevaleur) in (list, tuple)):
- listevaleur = tuple(listevaleur)
- # on verifie que la cardinalite max n a pas ete atteinte
- min, max = self.node.item.getMinMax()
- if len(listecourante) + len(listevaleur) > max:
- commentaire = (
- "La liste atteint le nombre maximum d'elements : "
- + str(max)
- + " ,ajout refuse"
- )
- return False, commentaire, commentaire2, listeRetour
-
- for valeur in listevaleur:
- # On teste le type de la valeur
- valeurScientifique = valeur
- valide = self.node.item.valideItem(valeur)
- if not valide:
- try:
- valeur, valide = self.node.item.evalValeur(valeur)
- valide, commentaire2 = self.node.item.object.verifType(valeur)
- except:
- # return testtype,commentaire,"",listeRetour
- pass
- if not valide:
- if commentaire.find("On attend un chaine") > 1:
- commentaire = (
- "Valeur "
- + str(valeur)
- + " incorrecte : ajout a la liste refuse: On attend une chaine de caracteres < 8"
- )
- else:
- commentaire = (
- "Valeur "
- + str(valeur)
- + " incorrecte : ajout a la liste refuse"
- )
- if commentaire2 == "":
- commentaire2 = self.node.item.infoErreurItem()
- return valide, commentaire, commentaire2, listeRetour
-
- # On valide la liste obtenue
- encorevalide = self.node.item.valideListePartielle(valeur, listecourante)
- if not encorevalide:
- commentaire2 = self.node.item.infoErreurListe()
- # On traite le cas ou la liste n est pas valide pour un pb de cardinalite
- min, max = self.node.item.getMinMax()
- if len(listecourante) + 1 >= max:
- commentaire = (
- "La liste atteint le nombre maximum d'elements : "
- + str(max)
- + " ,ajout refuse"
- )
- return valide, commentaire, commentaire2, listeRetour
- if len(listecourante) + 1 > min:
- commentaire = ""
- return valide, commentaire, commentaire2, listeRetour
- # On ajoute la valeur testee a la liste courante et a la liste acceptee
- self.ajoutDsDictReel(valeurScientifique)
- listecourante.insert(index, valeur)
- index = index + 1
- listeRetour.append(valeur)
-
- return valide, commentaire, commentaire2, listeRetour
-
- def ajoutTuple(self, valeurTuple, listecourante):
- listeRetour = []
- commentaire = "Nouvelle valeur acceptee"
- commentaire2 = ""
- valide = 1
- if valeurTuple == None:
- return
- if valeurTuple == [""]:
- return
- # On teste le type de la valeur
- valide = self.node.item.valideItem(valeurTuple)
- if not valide:
- try:
- valeur, valide = self.node.item.evalValeur(valeurTuple)
- valide = self.node.item.valideItem(valeur)
- except:
- pass
- if not valide:
- commentaire = (
- "Valeur " + str(valeurTuple) + " incorrecte : ajout a la liste refuse"
- )
- commentaire2 = self.node.item.infoErreurItem()
- return valide, commentaire, commentaire2, listeRetour
-
- # On valide la liste obtenue
- encorevalide = self.node.item.valideListePartielle(valeurTuple, listecourante)
- if not encorevalide:
- commentaire2 = self.node.item.infoErreurListe()
- return valide, commentaire, commentaire2, listeRetour
- listeRetour.append(valeurTuple)
- return valide, commentaire, commentaire2, listeRetour
-
- def ajoutNTuple(self, liste):
- commentaire = "Nouvelles valeurs acceptee"
- commentaire2 = ""
- valide = self.node.item.valideListePartielle(None, liste)
- print("uuuuuuuuuuu", valide)
- if not valide:
- commentaire2 = self.node.item.infoErreurListe()
- return valide, commentaire, commentaire2
-
- def recordValeur(self, liste, dejaValide=True):
- ancienneVal = self.node.item.getValeur()
- validite = self.node.item.setValeur(liste)
- if validite:
- self.node.item.initModif()
- if self.node.item.isValid():
- commentaire = tr("Valeur du mot-cle enregistree")
- else:
- cr = self.node.item.getCr()
- commentaire = tr("Valeur du mot-cle non autorisee ") + cr.getMessFatal()
- self.node.item.setValeur(ancienneVal)
- return validite, commentaire
from Editeur import session
from UiQT5.myMain import Ui_Eficas
from InterfaceGUI.QT5.viewManager import MyViewManager
-from InterfaceGUI.qtEficasSsIhm import AppliSsIhm
+from InterfaceGUI.appliSsIhm import AppliSsIhm
from Extensions.i18n import tr
from Extensions.eficas_exception import EficasException
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-import types
-from Extensions.i18n import tr
-
-from PyQt5.QtCore import Qt
-
-
-# Import des panels
-
-
-class SaisieValeur(object):
- """
- Classe contenant les methodes communes aux panels
- permettant de choisir des valeurs
- """
-
- def __init__(self):
- pass
-
- def LEvaleurPressed(self, valeur=None):
- # print('LEvaleurPressed', valeur, type(valeur))
- if not hasattr(self, "inSaisieValeur"):
- self.inSaisieValeur = False
- if self.inSaisieValeur:
- return
- self.inSaisieValeur = True
-
- if valeur == None:
- try:
- nouvelleValeur = str(self.lineEditVal.text())
- except UnicodeEncodeError as e:
- self.editor.afficheInfos("pb d encoding", Qt.red)
- validite, commentaire = self.politique.recordValeur(None)
- self.lineEditVal.setText("")
- self.setValide()
- self.inSaisieValeur = False
- return
- else:
- try:
- # la 1 ligne est tres bizarre. remplacee par le 3nd le 01 10 19
- # if hasattr(self,"lineEditVal"):self.lineEditVal.setText(tr(valeur.nom))
- if hasattr(self, "lineEditVal"):
- self.lineEditVal.setText(tr(valeur))
- except:
- if hasattr(self, "lineEditVal"):
- self.lineEditVal.setText(valeur)
- nouvelleValeur = valeur
-
- if self.node.item.definition.validators != None:
- if self.node.item.definition.validators.verifItem(nouvelleValeur) != 1:
- commentaire = self.node.item.definition.validators.infoErreurItem()
- self.editor.afficheInfos(commentaire, Qt.red)
- self.inSaisieValeur = False
- return
-
- nouvelleValeurFormat = self.politique.getValeurTexte(nouvelleValeur)
- validite, commentaire = self.politique.recordValeur(nouvelleValeurFormat)
- if commentaire != "":
- if validite:
- self.editor.afficheCommentaire(commentaire)
- else:
- self.editor.afficheInfos(commentaire, Qt.red)
- self.inSaisieValeur = False
- self.setValide()
-
- def TraiteLEValeur(self, valeurTraitee=None):
- # lit la chaine entree dans le line edit
- # et la tranforme en chaine de valeurs
- # a traiter. renvoie eventuellement des complexes
- listeValeurs = []
- if valeurTraitee == None:
- valeurBrute = str(self.LEValeur.text())
- else:
- valeurBrute = valeurTraitee
- if valeurBrute == str(""):
- return listeValeurs, 1
-
- try:
- valeur = eval(valeurBrute, {})
- except:
- valeur = valeurBrute
-
- # pour traiter 11.0 - 30.0 pour le CIST
- # if (valeurTraitee and (type(valeurTraitee) in types.StringTypes) and (self.node.item.waitTxm())) :
- if (
- valeurTraitee
- and isinstance(valeurTraitee, str)
- and (self.node.item.waitTxm())
- ):
- valeur = str(valeurTraitee)
-
- if type(valeur) in (list, tuple):
- if self.node.item.waitComplex():
- indice = 0
- while indice < len(valeur):
- v = valeur[indice]
-
- if v == "RI" or v == "MP":
- try:
- t = tuple([v, valeur[indice + 1], valeur[indice + 2]])
- listeValeurs.append(t)
- indice = indice + 3
- except:
- commentaire = tr(
- "Veuillez entrer le complexe sous forme aster ou sous forme python"
- )
- self.editor.afficheInfos(commentaire)
- return listeValeurs, 0
-
- else: # ce n'est pas un tuple a la mode aster
- listeValeurs.append(v)
- indice = indice + 1
-
- else: # on n'attend pas un complexe
- listeValeurs = valeurBrute.split(",")
-
- elif type(valeur) == bytes:
- listeValeurs = valeur.split(",")
- else:
- # listeValeurs.append(valeurBrute)
- listeValeurs.append(valeur)
-
- return listeValeurs, 1
-
-
-class SaisieSDCO(object):
- def LESDCOReturnPressed(self):
- """
- Lit le nom donne par l'utilisateur au concept de type CO qui doit être
- la valeur du MCS courant et stocke cette valeur
- """
- self.editor.initModif()
- anc_val = self.node.item.getValeur()
- if anc_val != None:
- # il faut egalement propager la destruction de l'ancien concept
- self.node.item.deleteValeurCo(valeur=anc_val)
- # et on force le recalcul des concepts de sortie de l'etape
- self.node.item.object.etape.getType_produit(force=1)
- # et le recalcul du contexte
- self.node.item.object.etape.parent.resetContext()
- nomConcept = str(self.LESDCO.text())
- if nomConcept == "":
- return
-
- test, commentaire = self.node.item.setValeurCo(nomConcept)
- if test:
- commentaire = tr("Valeur du mot-clef enregistree")
- self.node.updateNodeValid()
- else:
- cr = self.node.item.getCr()
- commentaire = tr("Valeur du mot-clef non autorisee :") + cr.getMessFatal()
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import re
+import types,sys,os
+import traceback
+
+from Extensions.i18n import tr
+
+#------------------------------------------
+class JDCTree():
+#------------------------------------------
+
+ def __init__( self, jdc_item, editor):
+ #----------------------------------------
+ #print ('__init__ JDCTree')
+ self.editor = editor
+ self.plie = False
+ self.item = jdc_item
+ self.tree = self
+ self.appliEficas = self.editor.appliEficas
+ self.racine = self.item.itemNode(self,self.item)
+ self.itemCourant=None
+ self.node_selected = self.racine
+ self.inhibeExpand = True
+ self.childrenComplete=[]
+ self.oldValidite='init'
+ #print ('fin __init__ JDCTree')
+
+ # def handleContextMenu(self,item,coord):
+ #-------------------------------------
+ # def handleCollapsedItem(self,item):
+ #----------------------------------
+ # def handleExpandedItem(self,item):
+ #----------------------------------
+ # def handleOnItem(self,item,int):
+ #----------------------------------
+ # def choisitPremier(self,name):
+ #----------------------------
+# type de noeud
+COMMENT = "COMMENTAIRE"
+PARAMETERS = "PARAMETRE"
+
+#---------------
+class JDCNode():
+#--------------
+ def __init__( self, treeParent, item, itemExpand=False, ancien=False ):
+ #----------------------------------------------------------------------
+ #print ("creation d'un noeud : ", item, " ",item.nom,"", treeParent, treeParent.item.nom,self)
+ self.item = item
+ self.vraiParent = treeParent
+ self.treeParent = treeParent
+ self.tree = self.treeParent.tree
+ self.editor = self.treeParent.editor
+ self.appliEficas = treeParent.appliEficas
+ self.firstAffiche = True
+ self.childrenComplete=[]
+ self.oldValidite = 'init'
+ self.oldRepetable = 'init'
+ self.oldStatut = 'init'
+ self.item.fauxNoeudGraphique = self
+ if item.nom != tr(item.nom) : name = str(tr(item.nom)+" :")
+
+ from . import compomclist
+ from . import compobloc
+ while (isinstance(self.treeParent,compobloc.Node) or ( isinstance(self.treeParent,compomclist.Node) and self.treeParent.item.isMCList())) :
+ self.treeParent=self.treeParent.vraiParent
+
+ self.children = []
+ self.buildChildren()
+
+ self.item.connect("valid",self.onValid,())
+ self.item.connect("supp" ,self.onSupp,())
+ self.item.connect("add" ,self.onAdd,())
+ self.item.connect("demandeUpdateOptionnels" ,self.updateOptionnels,())
+
+
+ def onValid(self):
+ #-----------------
+ debug=0
+ validite=self.item.isValid()
+ if debug : print ('ds onValid', self.item.nom, self.oldValidite, validite)
+ if self.oldValidite==validite : return
+ if self.oldValidite=='init' :
+ self.oldValidite=validite
+ if debug : print ('self.item.state' , self.item.state)
+ if self.item.state != 'modified' : return
+ self.oldValidite=validite
+ self.editor.connecteur.toWebApp('propageValide',self.getIdUnique(), validite)
+ if debug : print ('appel de propageValide pour ', self.item.nom, validite,self.oldValidite)
+
+ def onAdd(self,ajout):
+ #----------------------
+ # derive pour MCList et MCBLOC
+ debug=0
+ if debug : print ('on add de browser', '________ ajout', ajout, ' dans ', self.item.nom)
+ if debug : print ('nature de l item', self.item.nature)
+ #if self.oldValidite=='init' : self.oldValidite='unknown'
+ self.buildChildren()
+
+ # si on a un copie multiple --> pas gere correctement
+ # pas gere du tout
+ if len(ajout) > 1 :
+ return
+
+ # test inutile
+ ouAjouter=self.getIdUnique()
+
+ mcAjoute= ajout[0]
+ posDansSelf = 0;
+ trouve=0
+ posDansArbre=0
+ for c in self.children :
+ if c.item._object == mcAjoute :
+ trouve=1
+ break
+ posDansSelf +=1
+ posDansArbre+=c.item.longueurDsArbreAvecConsigne()
+
+ if not trouve : print ('browser : souci au add *************************')
+ if debug : print ('uuuu posDansSelf', posDansSelf)
+ if debug : print ('posDansArbre', posDansArbre)
+
+ if self.children[posDansSelf].item.nature == 'MCBLOC' : laListe=self.children[posDansSelf].item.getDicoForFancy()
+ elif self.children[posDansSelf].item.nature == 'MCList' : laListe=self.children[posDansSelf].item.getDicoForFancy()
+ else : laListe=(self.children[posDansSelf].item.getDicoForFancy(),)
+
+ posOuAjouter=posDansArbre
+
+ self.editor.connecteur.toWebApp('appendChildren',ouAjouter,laListe,posOuAjouter)
+ #print ('la pos ', posOuAjouter)
+ #print (' appel appendChild',self.item.idUnique,laListe,pos)
+
+ def onSupp(self,suppression):
+ #---------------------------
+ #if self.treeParent.oldValidite=='init' : self.treeParent.oldValidite='unknown'
+ if len(suppression) > 1 :
+ print ('onSupp suppression multiple non valeur')
+ return
+ mcSupprime= suppression[0]
+ if mcSupprime.nature == 'MCBLOC' :
+ liste=[]
+ listeMC=mcSupprime.getAllChildInBloc()
+ for mc in listeMC : liste.append(mc.idUnique)
+ elif mcSupprime.nature == 'MCList' :
+ liste=[]
+ for mc in mcSupprime.data :
+ liste.append(mc.idUnique)
+ else :
+ liste=(mcSupprime.idUnique,)
+ self.buildChildren()
+ self.updateOptionnels()
+ self.editor.connecteur.toWebApp('deleteChildren',liste)
+ #print (' appel deleteChildren',liste)
+
+ def onRedessine(self):
+ #----------------------
+ print ('on Redessine pour ', self)
+ #---------------------
+ # self.affichePanneau()
+
+ def getIdUnique(self):
+ #---------------------
+ # surcharge pour mcliste
+ return self.item.idUnique
+
+ def getTreeParentIdUnique(self):
+ #------------------------------
+ return self.treeParent.getIdUnique()
+
+ def buildChildren(self,posInsertion=10000):
+ #------------------------------------------
+ """ Construit la liste des enfants de self """
+ """ Se charge de remettre les noeuds Expanded dans le meme etat """
+ debug=0
+ if debug : print ("*********** buildChildren ",self,self.item, self.item.nom,self.children)
+ if debug : print ("*********** buildChildren ",self,self.item, self.item.nom)
+
+
+ self.children = []
+ self.childrenItemComplete = []
+ sublist = self.item._getSubList()
+ if debug :
+ print ('sublist : ')
+ for s in sublist : print (s.nom)
+ ind=0
+
+ # si le faux noeud graphique existe deja on ne le recree pas
+ # sinon on a trop de connect sur les items
+ for item in sublist :
+ if hasattr(item,'fauxNoeudGraphique') :
+ self.children.append(item.fauxNoeudGraphique)
+ else:
+ nouvelItem=item.itemNode(self,item)
+ item.fauxNoeudGraphique=nouvelItem
+ self.children.append(nouvelItem)
+
+ self.childrenItemComplete=self.construitChildrenComplete()
+
+ if debug : print ("fin *********** buildChildren ",self,self.item, self.item.nom, self.children)
+
+
+ def construitChildrenComplete(self):
+ # PN a tester avec des blocs de blocs
+ from . import compobloc
+ liste=[]
+ for itemFils in self.item._getSubList():
+ if isinstance(itemFils,compobloc.Node):
+ for itemPetitFils in itemFils.construitChildrenComplete():
+ liste.append(itemPetitFils)
+ itemPetitFils.treeParent=self
+ else :
+ liste.append(itemFils)
+ return liste
+
+
+ def getDicoObjetsPourWeb(self):
+ return self.item.getDicoObjetsPourWeb()
+
+ def getDicoObjetsCompletsPourTree(self):
+ #print ('browser getDicoObjetsCompletsPourTree', self, ' ', self.item)
+ return self.item.getDicoObjetsCompletsPourTree()
+
+ def getDicoForFancy(self):
+ return self.item.getDicoForFancy()
+
+ def appendChild(self,name,pos=None):
+ #-----------------------------------
+ """
+ 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.
+ Attention a la delegation et aux dictionnaires
+ """
+ debug=0
+ if debug : print ("************** appendChild ",self.item.getLabelText(), pos, name )
+
+ if self.item.nature != 'JDC' : dictMCVenantDesBlocs=self.item.object.dictMCVenantDesBlocs
+ else : dictMCVenantDesBlocs={}
+
+ if debug : print ("dictMCVenantDesBlocs" , dictMCVenantDesBlocs)
+ if name in dictMCVenantDesBlocs :
+ # cas d un MC sous un bloc
+ mcPere = self.item.object.dictMCVenantDesBlocs[name]
+ try :
+ 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 = mcPere.getIndex(pos) +1 # pos est un item. Il faut inserer name apres pos
+ elif type(name) == object : index = mcPere.getIndexChild(name.nom)
+ elif self.item.nature != 'JDC' : index = mcPere.getIndexChild(name)
+ else : index = self.item.getIndexChild(name)
+ #else : return None
+ except :
+ txt=' Impossible d ajouter {} en position {}'.format(name, pos)
+ self.editor.afficheInfos(txt,'rouge')
+ return None
+ if debug : print ('name : ', name, ' a pour index : ', index)
+ obj = mcPere.addEntite(name,index)
+ if debug : print ('mcPere', mcPere.nom, mcPere.mcListe)
+ else :
+ try :
+ 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)
+ elif self.item.nature != 'JDC' : index = self.item.getIndexChild(name)
+ else : index = self.item.getIndexChild(name)
+ #else : return None
+ except :
+ txt=' Impossible d ajouter {} en position {}'.format(name, pos)
+ self.editor.afficheInfos(txt,'rouge')
+ return None
+ if debug : print ('name : ', name, ' a pour index : ', index)
+ obj = self.item.addEntite(name,index) # emet le signal 'add'
+
+ if not obj : return None
+ if debug : print ('obj', obj.nom, obj.mcListe)
+ self.updateOptionnels()
+ return True
+ #return child.getIdUnique()
+
+ def delete(self):
+ #----------------
+ """
+ Methode externe pour la destruction de l'objet associe au noeud
+ """
+ #print ('browser :_appel de delete _______', self, self.vraiParent, self.item.nature)
+
+ ret,commentaire=self.vraiParent.item.suppItem(self.item)
+ if ret!=0 :
+ self.treeParent.buildChildren()
+ self.treeParent.updateOptionnels()
+ return (ret,commentaire)
+
+ def updateNodeLabel(self):
+ #-------------------------
+ monDictPartiel={}
+ label=self.item.getLabelText()[0]
+ if label[-1]==":" : label=label[0:-1]
+ monDictPartiel['title']=label
+ self.editor.connecteur.toWebApp('updateNodeInfo',self.getIdUnique(), monDictPartiel)
+
+ def updateRepetable(self,isRepetable):
+ #-------------------------------------
+ if self.oldRepetable == isRepetable : return
+ self.oldRepetable = isRepetable
+ monDictPartiel={}
+ monDictPartiel['repetable']=isRepetable
+ self.editor.connecteur.toWebApp('updateNodeInfo',self.getIdUnique(), monDictPartiel)
+
+ def updateStatut(self,statut):
+ #-----------------------------
+ if self.oldStatut == statut : return
+ self.oldStatut = statut
+ monDictPartiel={}
+ monDictPartiel['statut']=statut
+ self.editor.connecteur.toWebApp('updateNodeInfo',self.getIdUnique(), monDictPartiel)
+
+ def updateOptionnels(self):
+ #---------------------------
+ if self.item.nature == 'MCList' or self.item.nature == 'JDC' or self.item.nature=='MCSIMP' : return
+ monDictPartiel={}
+ monDictPartiel['infoOptionnels'] = self.item.calculOptionnelInclutBlocs()
+ self.editor.connecteur.toWebApp('updateNodeInfo',self.getIdUnique(), monDictPartiel)
+
+ #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):
+ #-------------------------
+ #def getPanelModifie(self):
+ #-------------------------
+ #def affichePanneau(self) :
+ #-------------------------
+ #def createPopUpMenu(self):
+ #-------------------------
+ #def commentIt(self):
+ #-------------------------
+ #def unCommentIt(self):
+ #-------------------------
+ #def addComment( self, after=True ):
+ #-----------------------------------
+ #def addParameters( self, after=True ):
+ #-------------------------------------
+ #def select( self ):
+ #------------------
+ #------------------------------------------------------------------
+ # Methodes de creation et destruction de noeuds
+ #------------------------------------------------------------------
+ #def appendBrother(self,name,pos='after',plier=False):
+ #----------------------------------------------------
+ #def verifiePosition(self,name,pos,aLaRacine=False):
+ #----------------------------------------------------
+ #def deplace(self):
+ #-----------------
+ #def deleteMultiple(self,liste=()):
+ #--------------------------------
+
+ #def updateNodeValid(self):
+ #-----------------------
+
+ #def updateNodeLabelInBlack(self):
+ #-------------------------------
+ #def updateNodeLabelInBlue(self):
+ #-------------------------------
+ #def updatePlusieursNodeLabelInBlue(self,liste):
+ #----------------------------------------------
+ #def updateNodeTexteInBlack(self):
+ #--------------------------------
+ #def updateNodeTexte(self):
+ #----------------------------
+ #def updateNodeTexteInBlue(self):
+ #--------------------------------
+ #def updateNodes(self):
+ #--------------------------------
+ #def updateValid(self) :
+ #----------------------
+ #def updateTexte(self):
+ #----------------------
+ #def forceRecalculChildren(self,niveau):
+ #--------------------------------------
+ #def doPaste(self,node_selected,pos='after'):
+ #--------------------------------------------
+ #def doPasteCommande(self,objet_a_copier,pos='after'):
+ #-----------------------------------------------------
+ #def doPastePremier(self,objet_a_copier):
+ #---------------------------------------
+ #def plieToutEtReafficheSaufItem(self, itemADeplier):
+ #---------------------------------------------------
+ #def plieToutEtReaffiche(self):
+ #-----------------------------
+ #def deplieToutEtReaffiche(self):
+ #-----------------------------
+ #def setPlie(self):
+ #-----------------
+ #def setPlieChildren(self):
+ #-----------------------------
+ #def setDeplie(self):
+ #-----------------------------
+ #def setDeplieChildren(self):
+ #-----------------------------
+ #def selectAvant(self):
+ #-----------------------------
+ #def selectApres(self):
+ #---------------------
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+
+from Editeur import Objecttreeitem
+
+from InterfaceGUI.Web import compofact
+from InterfaceGUI.Web import browser
+from InterfaceGUI.Web import typeNode
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
+
+
+
+ def onAdd(self,ajout):
+ #----------------------
+ debug=0
+ if debug : print ('on add de mcbloc', '________ ajout', ajout, ' dans ', self.item.nom)
+ if debug : print ('nature de l item', self.item.nature)
+ self.buildChildren()
+
+ # si on a un copie multiple --> pas gere correctement
+ # pas gere du tout
+ if len(ajout) > 1 :
+ print ('ajout multiple non gere')
+ return
+
+ ouAjouter=self.getTreeParentIdUnique()
+
+ mcAjoute= ajout[0]
+ posDansSelf = 0;
+ trouve=0
+ posDansArbre=0
+
+ for c in self.children :
+ if c.item._object == mcAjoute :
+ trouve=1
+ break
+ posDansSelf +=1
+ posDansArbre+=c.item.longueurDsArbreAvecConsigne()
+ if not trouve : print ('souci au add *************************')
+ if debug : print ('posDansSelf', posDansSelf)
+ if debug : print ('posDansArbre', posDansSelf)
+ if self.children[posDansSelf].item.nature == 'MCBLOC' : laListe=self.children[posDansSelf].item.getDicoForFancy()
+ else : laListe=(self.children[posDansSelf].item.getDicoForFancy(),)
+
+ posOuAjouter=posDansArbre
+ mesParents=self.item.getParentsJusqua(self.treeParent.item)
+ mesParents.insert(0,self.item.getObject())
+ index=0
+ while index < len(mesParents) -1 :
+ parentTraite=mesParents[index+1]
+ jusqua=mesParents[index]
+ for c in parentTraite.mcListe:
+ if c == jusqua : break
+ posOuAjouter += c.longueurDsArbreAvecConsigne()
+ index=index+1
+
+
+ self.editor.connecteur.toWebApp('appendChildren',ouAjouter,laListe,posOuAjouter)
+ #print ('la pos ', posOuAjouter)
+ #print (' appel appendChild',self.item.idUnique,laListe,pos)
+
+
+class BLOCTreeItem(compofact.FACTTreeItem):
+ itemNode=Node
+
+ def isCopiable(self):
+ return 0
+
+
+import Accas
+treeitem = BLOCTreeItem
+objet = Accas.MCBLOC
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from InterfaceGUI.Web import browser
+from InterfaceGUI.Web import typeNode
+from Extensions.i18n import tr
+from Editeur import Objecttreeitem
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNodePartiel):
+
+
+ def delete(self):
+ #----------------
+ """
+ Methode externe pour la destruction de l'objet associe au noeud
+ """
+ debug = 0
+ if debug : print ('******* mcfact :_appel de delete _______', self, self.vraiParent, self.item.nature)
+ if len(self.vraiParent.item._object) == 1 :
+ treeParent=self.vraiParent.treeParent
+ ret,commentaire=self.vraiParent.treeParent.item.suppItem(self.vraiParent.item)
+ if ret!=0 : treeParent.buildChildren()
+ return (ret,commentaire)
+
+
+ obj=self.item.getObject()
+ indexFact=self.vraiParent.item._object.index(obj)
+ ret,commentaire=self.vraiParent.item.suppItem(self.item)
+ if not ret : return (ret,commentaire)
+ self.treeParent.buildChildren()
+ self.vraiParent.buildChildren()
+ for c in self.vraiParent.children[indexFact:] :
+ c.updateNodeLabel()
+ self.treeParent.updateOptionnels()
+ return (ret,commentaire)
+
+
+
+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"
+
+
+ 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
+ dans 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
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from Editeur import Objecttreeitem
+from InterfaceGUI.Web import browser
+from InterfaceGUI.Web import typeNode
+from Extensions.i18n import tr
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuRacine):
+
+
+ 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 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
+
+ def getValidite(self):
+ return self.object.isValid()
+
+
+
+import Accas
+treeitem =JDCTreeItem
+objet = Accas.JDC
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import types
+import traceback
+
+from InterfaceGUI.Web import compofact
+from InterfaceGUI.Web import browser
+from InterfaceGUI.Web import typeNode
+from Extensions.i18n import tr
+
+from Editeur import Objecttreeitem
+from Noyau.N_OBJECT import ErrorObj
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
+
+
+ def __init__( self, treeParent, item, itemExpand=False, ancien=False ):
+ #--------------------------------------------------------------------
+ browser.JDCNode.__init__(self, treeParent, item, itemExpand,ancien)
+ # depend si le comm contient deja une liste ou si elle cree a l ihm
+ if self.item.nature == 'MCList' :
+ self.minListe = self.item.data[0].definition.min
+ self.maxListe = self.item.data[0].definition.max
+ self.statutListe= self.item.data[0].definition.statut
+ else:
+ self.minListe = self.item.definition.min
+ self.maxListe = self.item.definition.max
+ self.statutListe= self.item.definition.statut
+
+ def getIdUnique(self):
+ #---------------------
+ print ('pas d iD unique pour la MCLIST')
+ # on renvoie l'ID du 1er MCFact
+ # print (self.item._object[0].idUnique)
+ return self.item._object[0].idUnique
+
+ def onValid(self):
+ #-----------------
+ # on ne fait rien
+ pass
+
+ def onValidBad(self):
+ #-----------------
+ #print( self.item.nature)
+ if self.item.nature == 'MCFACT' :
+ validite=self.item.isValid()
+ if self.oldValidite != validite :
+ self.editor.connecteur.toWebApp('propageValide',self.item.idUnique, validite)
+ self.oldValidite = validite
+
+ if self.item.state != 'modified' : return
+ self.treeParent.item.state= 'modified'
+
+ def onAdd(self,ajout):
+ #----------------------
+ debug=0
+ if debug : print (' ***************** on add de compomclist', 'ajout', ajout, ' dans ', self.item.nom, self.item, self)
+ if debug : print ('on add de compomclist', '______ ajout', ajout, ' dans ', self.item.nom, self.item, self)
+ if debug : print ('nature de l ajout', ajout[0].nature)
+
+ self.buildChildren()
+
+ # si on a un copie multiple --> pas gere correctement
+ # pas gere du tout
+ if len(ajout) > 1 :
+ print ('add multiple non gere')
+ return
+
+ ouAjouter=self.getTreeParentIdUnique()
+
+ mcAjoute= ajout[0]
+ posDansSelf = 0;
+ trouve=0
+ # a priori on ajoute toujours le dernier FACT a la MCListe
+ # on garde quand meme la boucle si cela evolue
+ for c in self.children :
+ if c.item._object == mcAjoute :
+ trouve=1
+ break
+ posDansSelf +=1
+ if not trouve : print ('souci au add *************************')
+ if debug : print ('posDansSelf', posDansSelf)
+ if debug : print (self.children[posDansSelf].item.getDicoForFancy())
+ laListe=(self.children[posDansSelf].item.getDicoForFancy(),)
+
+
+ posDansArbre = posDansSelf;
+ for c in self.treeParent.children :
+ if c == self: break
+ posDansArbre +=c.item.longueurDsArbreAvecConsigne()
+
+ if debug : print (' posDansArbre ', posDansArbre , ' posDansSelf ', posDansSelf)
+ self.editor.connecteur.toWebApp('appendChildren',ouAjouter,laListe,posDansArbre)
+ #print ('la pos ', posOuAjouter)
+ #print (' appel appendChild',self.item.idUnique,laListe,pos)
+ self.updateChildrenProperties()
+
+
+ def onSupp(self,suppression):
+ #---------------------------
+ browser.JDCNode.onSupp(self, suppression)
+ self.updateChildrenProperties()
+
+
+ def updateChildrenProperties(self):
+ #----------------------------------
+ if self.item.nature == 'MCFACT':
+ children=(self.item.fauxNoeudGraphique,)
+ children[0].updateNodeLabel()
+ else :
+ if len(self.item.data) == 2 : self.children[0].updateNodeLabel()
+ children=self.children
+ for nodeChild in children :
+ if nodeChild.item.isOblig() : newStatut ='o'
+ else : newStatut = 'f'
+ if newStatut != nodeChild.oldStatut :
+ nodeChild.updateStatut(newStatut)
+ nodeChild.oldStatut=newStatut
+ newRepetable=nodeChild.item.isRepetable()
+ if newRepetable != nodeChild.oldRepetable :
+ nodeChild.updateRepetable(newRepetable)
+ nodeChild.oldRepetable=newRepetable
+
+
+
+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):
+ # Avant 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):
+ self.setDelegate(self._object)
+ return
+ if len(self._object) > 1:
+ self.setDelegate(self._object)
+ else:
+ self.setDelegate(self._object.data[0])
+
+ 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
+
+ #if len(self._object) <= 1:
+ # self._object.data[0].alt_parent=self._object
+ # return compofact.FACTTreeItem.getSubList(self)
+
+ 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)
--- /dev/null
+#-*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import os
+
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+from Editeur import Objecttreeitem
+from InterfaceGUI.Web import browser
+from InterfaceGUI.Web import typeNode
+
+class Node(browser.JDCNode, typeNode.PopUpMenuNode):
+
+
+ def select(self):
+ pass
+
+ def updateSDName(self,nom):
+ debug=1
+ if debug : print ('updateSDName' , self.item.nom, nom)
+ bOk,message = self.item.nommeSd(nom)
+ if debug : print ('bool', bOk,'message', message)
+ return (bOk,message)
+ # 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
+ """
+ debug=0
+ if self.isActif(): liste=self.object.mcListe
+ else: liste=[]
+
+
+ if debug : print ('getSubList, liste', liste)
+ if debug : print ('getSubList, sublist', self.sublist)
+ 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
+ if debug :
+ print ('-------------------------')
+ for obj in liste : print (obj.nom)
+ print ('-------------------------')
+ 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
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module 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 InterfaceGUI.Web import browser
+from InterfaceGUI.Web import typeNode
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNodePartiel):
+ pass
+
+
+
+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
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Editeur import Objecttreeitem
+from InterfaceGUI.Web import compooper
+from InterfaceGUI.Web import browser
+from InterfaceGUI.Web import typeNode
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNode):
+
+ pass
+
+
+class ProcEtapeTreeItem(compooper.EtapeTreeItem):
+ itemNode=Node
+
+import Accas
+treeitem = ProcEtapeTreeItem
+objet = Accas.PROC_ETAPE
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# Modules Python
+try :
+ from builtins import str
+except : pass
+
+import types,os
+
+from copy import copy,deepcopy
+import traceback
+
+# Modules Eficas
+from Editeur import Objecttreeitem
+from Noyau.N_CR import justifyText
+from Accas import SalomeEntry
+from Accas import ASSD
+from Accas import UserASSD
+from Accas import UserASSDMultiple
+from InterfaceGUI.Web import typeNode
+from InterfaceGUI.Web import browser
+from InterfaceGUI.politiquesValidation import PolitiqueUnique
+from InterfaceGUI.politiquesValidation import PolitiquePlusieurs
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
+
+ def traiteValeurSaisie(self,valeur):
+ if self.item.get_definition().max==1 : self.politique = PolitiqueUnique (self, self.editor)
+ else : self.politique = PolitiquePlusieurs(self, self.editor)
+ if self.item.definition.validators != None :
+ if self.item.definition.validators.verifItem(nouvelleValeur) !=1 :
+ commentaire=self.node.item.definition.validators.infoErreurItem()
+ return (self.item.idUnique, commentaire, false)
+ nouvelleValeurFormat=self.politique.getValeurTexte(valeur)
+ validite,commentaire=self.politique.recordValeur(nouvelleValeurFormat)
+ if validite : self.treeParent.updateOptionnels()
+ return (self.item.idUnique, commentaire, validite)
+
+
+
+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 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.nom
+ 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 """
+ for ss_type in self.object.definition.type:
+ if repr(ss_type).find('Matrice') != -1 :
+ 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
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from __future__ import absolute_import
+from __future__ import print_function
+
+import types,sys,os, re
+import traceback
+
+
+# Modules Eficas
+from Extensions.i18n import tr
+
+from Editeur import session
+from Editeur import comploader
+from Editeur import Objecttreeitem
+from InterfaceGUI.Web import browser
+
+debug = False
+
+from InterfaceGUI.editorSsIhm import JDCEditorSsIhm
+
+
+class JDCWebEditor(JDCEditorSsIhm):
+# ------------------------------- #
+ """
+ Editeur de jdc
+ """
+
+ def __init__ (self,appliEficas,fichier = None, jdc= None, connecteur = None ):
+ #------------------------------------------------------------------------
+
+ self.connecteur=connecteur
+ JDCEditorSsIhm.__init__(self,appliEficas,fichier)
+ self.dicoIdNode={}
+ comploader.chargerComposants('Web')
+ self.tree=None
+ if self.jdc:
+ self.jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
+ if self.jdc_item :
+ self.tree = browser.JDCTree( self.jdc_item, self )
+
+
+ def getNodeById(self,nodeId ):
+ #-----------------------------
+ if nodeId in self.dicoIdNode : return self.dicoIdNode[nodeId]
+ else : return None
+
+ def reconstruitChaineDIndex(self,nodeId):
+ #---------------------------------------
+ if nodeId in self.dicoIdNode :
+ node=self.dicoIdNode[nodeId]
+ return JDCEditorSsIhm.reconstruitChaineDIndex(self,node)
+ else : return None
+
+
+ def getDicoObjetsCompletsPourTree(self,obj) :
+ #-----------------------------------
+ #print ('editor getDicoObjetsCompletsPourTree pour ' ,self, obj)
+ if self.tree == None : return {}
+ return obj.getDicoObjetsCompletsPourTree()
+
+ def getDicoObjetsPourWeb(self,obj) :
+ #-----------------------------------
+ if self.tree == None : return {}
+ return obj.getDicoObjetsPourWeb()
+
+ def getDicoForFancy(self,obj) :
+ #-----------------------------------
+ if self.tree == None : return {}
+ return obj.getDicoForFancy()
+
+ def afficheInfos(self,txt,couleur=None):
+ #---------------------------------------
+ self.connecteur.toWebApp('afficheInfos', txt, couleur)
+ JDCEditorSsIhm.afficheInfos(self,txt,couleur)
+
+ def afficheAlerte(self,titre,message):
+ #-------------------------------------
+ self.connecteur.toWebApp('afficheAlerte', titre , message)
+ JDCEditorSsIhm.afficheAlerte(self,titre,message)
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+#---------------------------#
+class PopUpMenuRacine(object) :
+#---------------------------#
+
+ def createPopUpMenu(self):
+ print ("createPopUpMenu de MenuRacine")
+
+
+ def addParametersApres(self):
+ print ("addParametersApres de MenuRacine")
+
+#---------------------------#
+class PopUpMenuNodeMinimal(object) :
+#---------------------------#
+
+ def createPopUpMenu(self):
+ print ("createPopUpMenu de PopUpMenuNodeMinimal")
+
+ def createActions(self):
+ print ("createActions")
+
+ def supprimeNoeud(self):
+ print ("supprimeNoeud")
+
+ def viewDoc(self):
+ print ("viewDoc")
+
+ def addParametersApres(self):
+ print ("addParametersApres")
+
+ def addParametersAvant(self):
+ print ("addParametersAvant")
+
+ def addCommApres(self):
+ print ("addCommApres")
+
+ def addCommAvant(self):
+ print ("addCommAvant")
+
+ def deplieCeNiveau(self):
+ print ("deplieCeNiveau")
+
+#--------------------------------------------#
+class PopUpMenuNodePartiel (PopUpMenuNodeMinimal):
+#---------------------------------------------#
+ def createPopUpMenu(self):
+ PopUpMenuNodeMinimal.createPopUpMenu(self)
+ print ("createPopUpMenu de PopUpMenuNodePartiel")
+
+
+#-----------------------------------------#
+class PopUpMenuNode(PopUpMenuNodePartiel) :
+#-----------------------------------------#
+ def createPopUpMenu(self):
+ PopUpMenuNodePartiel.createPopUpMenu(self)
+ print ("createPopUpMenu de PopUpMenuNode")
+
+ def commenter(self):
+ print ("commenter")
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+import os, sys
+
+from Extensions.eficas_exception import EficasException
+from InterfaceGUI.getVersion import getEficasVersion
+from InterfaceGUI.viewManagerSsIhm import MyViewManagerSsIhm
+from Editeur import session
+
+
+class AppliSsIhm:
+ """
+ Class implementing the main user interface.
+ """
+
+ def __init__( self, code=None, salome=1, parent=None, multi=False, langue="fr",
+ ssIhm=True, labelCode=None, genereXSD=False, versionCode=None, ssCode=None, fichierCata=None,
+ GUIPath=None,
+ ):
+ """
+ Constructor
+ """
+ version = getEficasVersion()
+ self.versionEficas = "Eficas QT5 Salome " + version
+ self.labelCode = labelCode
+ self.GUIPath = None
+
+ self.salome = salome
+ self.ssIhm = True
+ self.code = code
+ self.genereXSD = genereXSD
+ self.versionCode = versionCode
+ self.ssCode = ssCode
+
+ self.dict_reels = {}
+ self.fichierIn = None
+ self.fichierOut = None
+
+ self.recent = []
+ self.ficRecents = {}
+ self.mesScripts = {}
+ self.listePathAEnlever = []
+ self.repIcon = os.path.join( os.path.dirname(os.path.abspath(__file__)), "..", "Editeur", "icons")
+
+ if fichierCata == None: self.fichierCata = session.d_env.fichierCata
+ else: self.fichierCata = fichierCata
+
+ if session.d_env.labelCode: self.labelCode = session.d_env.labelCode
+ self.withXSD = session.d_env.withXSD
+
+ if self.salome:
+ try:
+ from Accas import eficasSalome
+ Accas.SalomeEntry = eficasSalome.SalomeEntry
+ except:
+ print("eficas hors salome")
+
+ self.multi = multi
+ # on peut avoir multi et sans Ihm si on est en Web
+ # if self.multi: print("pas de multi sans ihm")
+
+ if langue == "fr": self.langue = langue
+ else: self.langue = "ang"
+
+ if self.multi == False:
+ self.definitCode(code, ssCode)
+ if code == None: return
+ else :
+ # Est-ce que configBase a un interet avec le web
+ from InterfaceGUI.configuration import configBase
+ self.maConfiguration = configBase(self)
+
+ self.suiteTelemac = False
+ self.viewmanager = MyViewManagerSsIhm(self)
+ self.withUQ = False
+
+ def ajoutUQ(self):
+ self.withUQ = True
+ self.formatFichierIn = "pythonUQ" # par defaut
+
+ def definitCode(self, code, ssCode):
+ # ssCode sert pour Map
+ self.code = code
+ self.ssCode = ssCode
+ if self.code == None:
+ return # pour le cancel de la fenetre choix code
+
+ if ssCode != None:
+ self.formatFichierOut = ssCode # par defaut
+ prefsCode.NAME_SCHEME = ssCode
+ else:
+ self.formatFichierIn = "python" # par defaut
+ self.formatFichierOut = "python" # par defaut
+
+ from InterfaceGUI.configuration import configBase
+ self.maConfiguration = configBase(self)
+
+ if hasattr(self, "maConfiguration") and self.maConfiguration.translatorFichier:
+ from Extensions import localisation
+ localisation.localise( None, self.langue,
+ translatorFichier=self.maConfiguration.translatorFichier,
+ )
+ if self.withXSD:
+ self.maConfiguration.withXSD = True
+
+ def getSource(self, file):
+ # appele par Editeur/session.py
+ import convert
+
+ p = convert.plugins["python"]()
+ p.readfile(file)
+ texte = p.convert("execnoparseur")
+ return texte
+
+ def initEditor(self, fichier=None, jdc=None, units=None, include=0):
+ if (hasattr(self, "editor")) and self.editor != None:
+ print("un seul editeur par application")
+ sys.exit()
+ self.editor = self.viewmanager.getNewEditorNormal()
+
+ def initEditorNormal(self, fichier=None, jdc=None, units=None, include=0):
+ if (hasattr(self, "editor")) and self.editor != None:
+ print("un seul editeur par application")
+ sys.Exit()
+ # self.editor = JDCEditorSsIhm(self,fichier, jdc, self.myQtab,units=units,include=include)
+ self.editor = self.viewmanager.getNewEditorNormal()
+
+ def fileNew(self):
+ self.editor = self.initEditor()
+
+ def getEditor(self):
+ if (hasattr(self, "editor")) and self.editor != None:
+ return self.editor
+ self.initEditor()
+ return self.editor
+
+ def fileOpen(self, fichier):
+ fichierIn = os.path.abspath(fichier)
+ try:
+ monEditor = self.viewmanager.handleOpen(fichierIn)
+ except EficasException as exc:
+ print("poum")
+ monEditor = None
+ return monEditor
+
+ def fileSave(self):
+ if self.editor == None:
+ return False
+ ok, newName = editor.saveFileAs()
+ print("ok, newName ", ok, newName)
+
+ def fileSaveAs(self, fileName):
+ if self.editor == None:
+ return False
+ ok = editor.saveFileAs()
+ print("ok ", ok)
+
+ def dumpXsd(self, avecEltAbstrait=False):
+ currentCata = CONTEXT.getCurrentCata()
+ texteXSD = currentCata.dumpXsd(avecEltAbstrait)
+ return texteXSD
+
+ def afficheMessage(self, titre, texte,critical=True):
+ print ('__________________________')
+ print (tr(titre))
+ print ('')
+ print (tr(texte))
+ print ('__________________________')
+
+
+# ,self.fileSaveAs
+# ,self.fileClose
+# ,self.fileExit
+# ,self.jdcRapport
+# ,self.jdcRegles
+# ,self.jdcFichierSource
+# ,self.visuJdcPy
+
+
+if __name__ == "__main__":
+ # Modules Eficas
+ monEficas = AppliSsIhm(code="Adao", salome=0, labelCode="V83")
self.appliEficas.code = self.code
else:
self.readercata = self.appliEficas.readercata
- if self.readercata.fichierCata == None:
- return # Sortie Salome
- if self.readercata.cata == None:
- return # Sortie Salome
- if self.readercata.cata == 0:
- return # Sortie Salome
- self.titre = self.readercata.titre
+
+ if self.readercata :
+ self.titre = self.readercata.titre
self.formatFichierOut = self.appliEficas.formatFichierOut
self.formatFichierIn = self.appliEficas.formatFichierIn
self.maConfiguration.mesGenerators = generator
self.maConfiguration.mesconvertisseurs = convert
- try:
- self.XMLGenerator = generator.plugins["xml"]()
- except:
- self.XMLGenerator = None
- try:
- self.pythonGenerator = generator.plugins["python"]()
- except:
- self.pythonGenerator = None
+ try: self.XMLGenerator = generator.plugins["xml"]()
+ except: self.XMLGenerator = None
+ try: self.pythonGenerator = generator.plugins["python"]()
+ except: self.pythonGenerator = None
if self.formatFichierOut in generator.plugins.keys():
self.generator = generator.plugins[self.formatFichierOut]()
# ------- construction du jdc --------------
+ if self.readercata.cata == None:
+ if self.fichier is not None:
+ print ('fichier comm mais pas de cata')
+ return # Sortie Salome
+
self.nouveau = 0
if self.fichier is not None: # fichier jdc fourni
if jdc == None:
# -----------------------#
if "dico" in generator.plugins:
self.generator = generator.plugins["dico"]()
- texte_jdc = self.generator.gener(self.jdc)
- return texte_jdc
+ # print (self.generator)
+ jdc_formate = self.generator.gener(self.jdc)
+ # print (jdc_formate)
+ dico = self.generator.Dico
+ # print (dico)
+ return dico
+
+ # --------------------------------#
+ def generDicoPourWeb(self, obj=None):
+ # --------------------------------#
+ if obj == None:
+ obj = self.jdc
+ if "dico" in generator.plugins:
+ self.generator = generator.plugins["dico"]()
+ jdc_formate = self.generator.gener(self.jdc)
+ dico = self.generator.Dico
+ return dico
# -----------------------#
def generDicoPython(self):
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas import PARAMETRE
+from Extensions.i18n import tr
+
+
+# ----------------------------
+class ValidationSaisie(object):
+# ----------------------------
+ """
+ classe mere des classes de politique de validation des CHAMPS SAISIS
+ les valeurs saisies sont toutes des CHAINES DE CARACTERE
+ il faut transformer '5' en 5 ou en 5. selon le type de l objet attendu
+ et 'MonNomDObjet' en MonNomDObjet
+ mais garder 'voici ma chaine de caractere '...
+ """
+ def __init__(self, node, parent):
+ # -------------------------------
+ self.node = node
+ self.parent = parent
+
+ def testeUneValeur(self, valeurentree):
+ # -------------------------------------
+ commentaire = None
+ # import traceback
+ # traceback.print_stack()
+ valeur, validite = self.node.item.evalValeur(valeurentree)
+ if not validite:
+ commentaire = "impossible d'evaluer : %s " % repr(valeurentree)
+ return valeur, validite, commentaire
+ if self.node.item.waitTxm() and not (type(valeur) == str):
+ valeur = str(valeur)
+
+ testtype, commentaire = self.node.item.object.verifType(valeur)
+ if not testtype:
+ return valeur, 0, commentaire
+
+ valide = self.node.item.valideItem(valeur)
+ if type(valide) == tuple:
+ validite, commentaire = valide
+ else:
+ validite = valide
+ commentaire = " "
+
+ if not validite and commentaire is None:
+ commentaire = "impossible d'evaluer : %s " % repr(valeurentree)
+ # print ('ds testeUneValeur', valeur, validite, commentaire)
+ return valeur, validite, commentaire
+
+ # ----------------------------------------------------------------------------------------
+ # Methodes utilisees pour la manipulation des items en notation scientifique
+ # a mettre au point
+ # ----------------------------------------------------------------------------------------
+ def setValeurTexte(self, texteValeur):
+ # ------------------------------------
+ try:
+ if "R" in self.node.item.object.definition.type:
+ if texteValeur[0] != "'":
+ clef = eval(texteValeur)
+ if str(clef) != str(texteValeur):
+ self.node.item.object.initModif()
+ clefobj = self.node.item.object.getNomConcept()
+ if not clefobj in self.parent.appliEficas.dict_reels:
+ self.parent.appliEficas.dict_reels[clefobj] = {}
+ self.parent.appliEficas.dict_reels[clefobj][clef] = texteValeur
+ self.parent.appliEficas.dict_reels[clefobj]
+ if clefobj == "":
+ if ( not self.node.item.object.etape in self.parent.appliEficas.dict_reels):
+ self.parent.appliEficas.dict_reels[ self.node.item.object.etape ] = {}
+ self.parent.appliEficas.dict_reels[ self.node.item.object.etape ][clef] = texteValeur
+ self.node.item.object.finModif()
+ except:
+ pass
+
+ # --------------------------------
+ def getValeurTexte(self, valeur):
+ # --------------------------------
+ valeurTexte = valeur
+ if valeur == None:
+ return valeur
+ from decimal import Decimal
+
+ if isinstance(valeur, Decimal):
+ if self.node.waitTxm() and not self.isParam(valeur):
+ return "'" + str(valeur) + "'"
+ else:
+ return valeur
+ if "R" in self.node.item.object.definition.type:
+ clefobj = self.node.item.object.getNomConcept()
+ if clefobj in self.parent.appliEficas.dict_reels:
+ if valeur in self.parent.appliEficas.dict_reels[clefobj]:
+ valeurTexte = self.parent.appliEficas.dict_reels[clefobj][valeur]
+ else:
+ if ( str(valeur).find(".") == -1 and str(valeur).find("e") == -1 and str(valeur).find("E")):
+ # aucun '.' n'a ete trouve dans valeur --> on en rajoute un a la fin
+ if self.isParam(valeur): return valeur
+
+ #else:
+ # try:
+ # val2 = eval(str(valeur) + ".")
+ # except: pass
+ return valeurTexte
+
+ # --------------------------------
+ def isParam(self, valeur):
+ # --------------------------------
+ for param in self.node.item.jdc.params:
+ if (repr(param) == repr(valeur)) or (str(param) == str(valeur)):
+ return 1
+ return 0
+
+ # -------------------------------------
+ def ajoutDsDictReel(self, texteValeur):
+ # -----------------------------------
+ # le try except est necessaire pour saisir les parametres
+ # on enleve l erreur de saisie 00 pour 0
+ if str(texteValeur) == "00": return
+ try:
+ if "R" in self.node.item.object.definition.type:
+ if str(texteValeur)[0] != "'":
+ clef = eval(texteValeur)
+ if str(clef) != str(texteValeur):
+ clefobj = self.node.item.object.getNomConcept()
+ if not clefobj in self.parent.appliEficas:
+ self.parent.appliEficas.dict_reels[clefobj] = {}
+ self.parent.appliEficas.dict_reels[clefobj][clef] = texteValeur
+ if clefobj == "":
+ if ( not self.node.item.object.etape in self.parent.appliEficas.dict_reels):
+ self.parent.appliEficas.dict_reels[ self.node.item.object.etape ] = {}
+ self.parent.appliEficas.dict_reels[ self.node.item.object.etape ][clef] = texteValeur
+ except:
+ pass
+
+ # -----------------------------
+ def ajoutDsDictReelEtape(self):
+ # -----------------------------
+ # janvier 24. Utile pour les formules ?
+ # a reconsiderer
+ # ajout du return
+ # a tester correctement
+ return
+ try:
+ if self.node.item.object in self.parent.appliEficas.dict_reels:
+ self.parent.appliEficas.dict_reels[ self.node.item.sdnom ] = self.parent.appliEficas.dict_reels[self.node.item.object]
+ del self.parent.appliEficas.dict_reels[self.node.item.object]
+ except:
+ pass
+
+
+# --------------------------------------
+class PolitiqueUnique(ValidationSaisie):
+# ---------------------_----------------
+ """
+ classe servant pour les entrees ne demandant qu un mot clef
+ """
+ def __init__(self, node, parent):
+ #--------------------------------
+ super().__init__()
+
+
+ def recordValeur(self, valeurentree):
+ #------------------------------------
+ if self.parent.modified == "n":
+ self.parent.initModif()
+ ancienneVal = self.node.item.getValeur()
+ valeur, validite, commentaire = self.testeUneValeur(valeurentree)
+ if ( validite and ("R" in self.node.item.object.definition.type) and not (isinstance(valeur, PARAMETRE))):
+ s = valeurentree
+ if s.find(".") == -1 and s.find("e") == -1 and s.find("E") == -1: s = s + "."
+ valeur, validite, commentaire = self.testeUneValeur(s)
+ if validite:
+ validite = self.node.item.setValeur(valeur)
+ if self.node.item.isValid():
+ commentaire = tr("Valeur du mot-cle enregistree")
+ self.setValeurTexte(str(valeurentree))
+ else:
+ cr = self.node.item.getCr()
+ commentaire = tr("Valeur du mot-cle non autorisee ") + cr.getMessFatal()
+ self.node.item.setValeur(ancienneVal)
+ return validite, commentaire
+
+
+# --------------------------------------
+class PolitiquePlusieurs(ValidationSaisie):
+# --------------------------------------
+ """
+ classe servant pour les entrees ne demandant qu un mot clef
+ """
+
+ def ajoutValeurs(self, listevaleur, index, listecourante):
+ #--------------------------------------------------------
+ listeRetour = []
+ commentaire = "Nouvelle valeur acceptee"
+ commentaire2 = ""
+ valide = 1
+ if listevaleur == None:
+ return
+ if listevaleur == "":
+ return
+ if not (type(listevaleur) in (list, tuple)):
+ listevaleur = tuple(listevaleur)
+ # on verifie que la cardinalite max n a pas ete atteinte
+ min, max = self.node.item.getMinMax()
+ if len(listecourante) + len(listevaleur) > max:
+ commentaire = (
+ "La liste atteint le nombre maximum d'elements : "
+ + str(max)
+ + " ,ajout refuse"
+ )
+ return False, commentaire, commentaire2, listeRetour
+
+ for valeur in listevaleur:
+ # On teste le type de la valeur
+ valeurScientifique = valeur
+ valide = self.node.item.valideItem(valeur)
+ if not valide:
+ try:
+ valeur, valide = self.node.item.evalValeur(valeur)
+ valide, commentaire2 = self.node.item.object.verifType(valeur)
+ except:
+ # return testtype,commentaire,"",listeRetour
+ pass
+ if not valide:
+ if commentaire.find("On attend un chaine") > 1:
+ commentaire = (
+ "Valeur "
+ + str(valeur)
+ + " incorrecte : ajout a la liste refuse: On attend une chaine de caracteres < 8"
+ )
+ else:
+ commentaire = (
+ "Valeur "
+ + str(valeur)
+ + " incorrecte : ajout a la liste refuse"
+ )
+ if commentaire2 == "":
+ commentaire2 = self.node.item.infoErreurItem()
+ return valide, commentaire, commentaire2, listeRetour
+
+ # On valide la liste obtenue
+ encorevalide = self.node.item.valideListePartielle(valeur, listecourante)
+ if not encorevalide:
+ commentaire2 = self.node.item.infoErreurListe()
+ # On traite le cas ou la liste n est pas valide pour un pb de cardinalite
+ min, max = self.node.item.getMinMax()
+ if len(listecourante) + 1 >= max:
+ commentaire = (
+ "La liste atteint le nombre maximum d'elements : "
+ + str(max)
+ + " ,ajout refuse"
+ )
+ return valide, commentaire, commentaire2, listeRetour
+ if len(listecourante) + 1 > min:
+ commentaire = ""
+ return valide, commentaire, commentaire2, listeRetour
+ # On ajoute la valeur testee a la liste courante et a la liste acceptee
+ self.ajoutDsDictReel(valeurScientifique)
+ listecourante.insert(index, valeur)
+ index = index + 1
+ listeRetour.append(valeur)
+
+ return valide, commentaire, commentaire2, listeRetour
+
+ def ajoutTuple(self, valeurTuple, listecourante):
+ listeRetour = []
+ commentaire = "Nouvelle valeur acceptee"
+ commentaire2 = ""
+ valide = 1
+ if valeurTuple == None:
+ return
+ if valeurTuple == [""]:
+ return
+ # On teste le type de la valeur
+ valide = self.node.item.valideItem(valeurTuple)
+ if not valide:
+ try:
+ valeur, valide = self.node.item.evalValeur(valeurTuple)
+ valide = self.node.item.valideItem(valeur)
+ except:
+ pass
+ if not valide:
+ commentaire = (
+ "Valeur " + str(valeurTuple) + " incorrecte : ajout a la liste refuse"
+ )
+ commentaire2 = self.node.item.infoErreurItem()
+ return valide, commentaire, commentaire2, listeRetour
+
+ # On valide la liste obtenue
+ encorevalide = self.node.item.valideListePartielle(valeurTuple, listecourante)
+ if not encorevalide:
+ commentaire2 = self.node.item.infoErreurListe()
+ return valide, commentaire, commentaire2, listeRetour
+ listeRetour.append(valeurTuple)
+ return valide, commentaire, commentaire2, listeRetour
+
+ def ajoutNTuple(self, liste):
+ commentaire = "Nouvelles valeurs acceptee"
+ commentaire2 = ""
+ valide = self.node.item.valideListePartielle(None, liste)
+ print("uuuuuuuuuuu", valide)
+ if not valide:
+ commentaire2 = self.node.item.infoErreurListe()
+ return valide, commentaire, commentaire2
+
+ def recordValeur(self, liste, dejaValide=True):
+ ancienneVal = self.node.item.getValeur()
+ validite = self.node.item.setValeur(liste)
+ if validite:
+ self.node.item.initModif()
+ if self.node.item.isValid():
+ commentaire = tr("Valeur du mot-cle enregistree")
+ else:
+ cr = self.node.item.getCr()
+ commentaire = tr("Valeur du mot-cle non autorisee ") + cr.getMessFatal()
+ self.node.item.setValeur(ancienneVal)
+ return validite, commentaire
+++ /dev/null
-# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-import os, sys
-
-from Extensions.eficas_exception import EficasException
-from InterfaceGUI.getVersion import getEficasVersion
-from InterfaceGUI.viewManagerSsIhm import MyViewManagerSsIhm
-from Editeur import session
-
-
-class AppliSsIhm:
- """
- Class implementing the main user interface.
- """
-
- def __init__( self, code=None, salome=1, parent=None, multi=False, langue="fr",
- ssIhm=True, labelCode=None, genereXSD=False, versionCode=None, ssCode=None, fichierCata=None,
- GUIPath=None,
- ):
- """
- Constructor
- """
- version = getEficasVersion()
- self.versionEficas = "Eficas QT5 Salome " + version
- self.labelCode = labelCode
- self.GUIPath = None
-
- self.salome = salome
- self.ssIhm = True
- self.code = code
- self.genereXSD = genereXSD
- self.versionCode = versionCode
- self.ssCode = ssCode
-
- self.dict_reels = {}
- self.fichierIn = None
- self.fichierOut = None
-
- self.recent = []
- self.ficRecents = {}
- self.mesScripts = {}
- self.listePathAEnlever = []
- self.repIcon = os.path.join( os.path.dirname(os.path.abspath(__file__)), "..", "Editeur", "icons")
-
- if fichierCata == None: self.fichierCata = session.d_env.fichierCata
- else: self.fichierCata = fichierCata
-
- if session.d_env.labelCode: self.labelCode = session.d_env.labelCode
- self.withXSD = session.d_env.withXSD
-
- if self.salome:
- try:
- from Accas import eficasSalome
- Accas.SalomeEntry = eficasSalome.SalomeEntry
- except:
- print("eficas hors salome")
-
- self.multi = multi
- if self.multi: print("pas de multi sans ihm")
-
- if langue == "fr": self.langue = langue
- else: self.langue = "ang"
-
- if self.multi == False:
- self.definitCode(code, ssCode)
- if code == None: return
- else :
- self.maConfiguration = configBase(self)
-
- self.suiteTelemac = False
- self.viewmanager = MyViewManagerSsIhm(self)
- self.withUQ = False
-
- def ajoutUQ(self):
- self.withUQ = True
- self.formatFichierIn = "pythonUQ" # par defaut
-
- def definitCode(self, code, ssCode):
- # ssCode sert pour Map
- self.code = code
- self.ssCode = ssCode
- if self.code == None:
- return # pour le cancel de la fenetre choix code
-
- if ssCode != None:
- self.formatFichierOut = ssCode # par defaut
- prefsCode.NAME_SCHEME = ssCode
- else:
- self.formatFichierIn = "python" # par defaut
- self.formatFichierOut = "python" # par defaut
-
- from InterfaceGUI.configuration import configBase
- self.maConfiguration = configBase(self)
-
- if hasattr(self, "maConfiguration") and self.maConfiguration.translatorFichier:
- from Extensions import localisation
- localisation.localise( None, self.langue,
- translatorFichier=self.maConfiguration.translatorFichier,
- )
- if self.withXSD:
- self.maConfiguration.withXSD = True
-
- def getSource(self, file):
- # appele par Editeur/session.py
- import convert
-
- p = convert.plugins["python"]()
- p.readfile(file)
- texte = p.convert("execnoparseur")
- return texte
-
- def initEditor(self, fichier=None, jdc=None, units=None, include=0):
- if (hasattr(self, "editor")) and self.editor != None:
- print("un seul editeur par application")
- sys.exit()
- self.editor = self.viewmanager.getNewEditorNormal()
-
- def initEditorNormal(self, fichier=None, jdc=None, units=None, include=0):
- if (hasattr(self, "editor")) and self.editor != None:
- print("un seul editeur par application")
- sys.Exit()
- # self.editor = JDCEditorSsIhm(self,fichier, jdc, self.myQtab,units=units,include=include)
- self.editor = self.viewmanager.getNewEditorNormal()
-
- def fileNew(self):
- self.editor = self.initEditor()
-
- def getEditor(self):
- if (hasattr(self, "editor")) and self.editor != None:
- return self.editor
- self.initEditor()
- return self.editor
-
- def fileOpen(self, fichier):
- fichierIn = os.path.abspath(fichier)
- try:
- monEditor = self.viewmanager.handleOpen(fichierIn)
- except EficasException as exc:
- print("poum")
- monEditor = None
- return monEditor
-
- def fileSave(self):
- if self.editor == None:
- return False
- ok, newName = editor.saveFileAs()
- print("ok, newName ", ok, newName)
-
- def fileSaveAs(self, fileName):
- if self.editor == None:
- return False
- ok = editor.saveFileAs()
- print("ok ", ok)
-
- def dumpXsd(self, avecEltAbstrait=False):
- currentCata = CONTEXT.getCurrentCata()
- texteXSD = currentCata.dumpXsd(avecEltAbstrait)
- return texteXSD
-
- def afficheMessage(self, titre, texte,critical=True):
- print ('__________________________')
- print (tr(titre))
- print ('')
- print (tr(texte))
- print ('__________________________')
-
-
-# ,self.fileSaveAs
-# ,self.fileClose
-# ,self.fileExit
-# ,self.jdcRapport
-# ,self.jdcRegles
-# ,self.jdcFichierSource
-# ,self.visuJdcPy
-
-
-if __name__ == "__main__":
- # Modules Eficas
- monEficas = AppliSsIhm(code="Adao", salome=0, labelCode="V83")
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import types
+from Extensions.i18n import tr
+
+#--------------------------
+class SaisieValeur(object):
+#--------------------------
+ """
+ Classe contenant les methodes communes aux panels
+ permettant de choisir des valeurs
+ """
+
+ def valeurChanged(self,valeur=None):
+ #-----------------------------------
+ # pour la partie Web
+ debug=0
+ if debug : print('valeurChanged', valeur, type(valeur))
+ nouvelleValeurFormat=self.politique.getValeurTexte(nouvelleValeur)
+ validite,commentaire=self.politique.recordValeur(nouvelleValeurFormat)
+ if commentaire != "" :
+ if validite : self.editor.afficheCommentaire(commentaire)
+ else : self.editor.afficheInfos(commentaire,'red')
+ self.inSaisieValeur=False
+ self.setValide()
+
+
+ def LEvaleurPressed(self, valeur=None):
+ #---------------------------------------
+ # pour la partie Qt
+ debug=0
+ if debug : print('LEvaleurPressed', valeur, type(valeur))
+ if not hasattr(self, "inSaisieValeur"): self.inSaisieValeur = False
+ if self.inSaisieValeur: return
+ self.inSaisieValeur = True
+
+ if valeur == None:
+ try:
+ nouvelleValeur = str(self.lineEditVal.text())
+ except UnicodeEncodeError as e:
+ self.editor.afficheInfos("pb d encoding", Qt.red)
+ validite, commentaire = self.politique.recordValeur(None)
+ self.lineEditVal.setText("")
+ self.setValide()
+ self.inSaisieValeur = False
+ return
+ else:
+ try:
+ # la 1 ligne est tres bizarre. remplacee par le 3nd le 01 10 19
+ # if hasattr(self,"lineEditVal"):self.lineEditVal.setText(tr(valeur.nom))
+ if hasattr(self, "lineEditVal"): self.lineEditVal.setText(tr(valeur))
+ except:
+ if hasattr(self, "lineEditVal"): self.lineEditVal.setText(valeur)
+ nouvelleValeur = valeur
+
+ if self.node.item.definition.validators != None:
+ if self.node.item.definition.validators.verifItem(nouvelleValeur) != 1:
+ commentaire = self.node.item.definition.validators.infoErreurItem()
+ self.editor.afficheInfos(commentaire, Qt.red)
+ self.inSaisieValeur = False
+ return
+
+ nouvelleValeurFormat = self.politique.getValeurTexte(nouvelleValeur)
+ validite, commentaire = self.politique.recordValeur(nouvelleValeurFormat)
+ if commentaire != "":
+ if validite: self.editor.afficheCommentaire(commentaire)
+ else: self.editor.afficheInfos(commentaire, 'red')
+ self.inSaisieValeur = False
+ self.setValide()
+
+ def TraiteLEValeur(self, valeurTraitee=None):
+ #---------------------------------------------
+ # pour Qt
+ # lit la chaine entree dans le lineedit
+ # et la tranforme en chaine de valeurs
+ # attention eventuellement aux complexes
+
+ listeValeurs = []
+ if valeurTraitee == None:
+ valeurBrute = str(self.LEValeur.text())
+ else:
+ valeurBrute = valeurTraitee
+ if valeurBrute == str(""): return listeValeurs, 1
+
+ return self.traiteValeurSaisie(valeurBrute)
+
+ def traiteValeurSaisie(self, valeurSaisie):
+ #---------------------------------------
+ # appelé directerment pour le web
+ # ou pour QT via la fonction TraiteLEValeur
+ listeValeurs = []
+ valeurBrute = valeurSaisie
+ try: valeur = eval(valeurBrute, {})
+ except: valeur = valeurBrute
+
+ # pour traiter 11.0 - 30.0 pour le CIST
+ # if (valeurTraitee and (type(valeurTraitee) in types.StringTypes) and (self.node.item.waitTxm())) :
+ if (
+ valeurTraitee
+ and isinstance(valeurTraitee, str)
+ and (self.node.item.waitTxm())
+ ):
+ valeur = str(valeurTraitee)
+
+ if type(valeur) in (list, tuple):
+ if self.node.item.waitComplex():
+ indice = 0
+ while indice < len(valeur):
+ v = valeur[indice]
+
+ if v == "RI" or v == "MP":
+ try:
+ t = tuple([v, valeur[indice + 1], valeur[indice + 2]])
+ listeValeurs.append(t)
+ indice = indice + 3
+ except:
+ commentaire = tr(
+ "Veuillez entrer le complexe sous forme aster ou sous forme python"
+ )
+ self.editor.afficheInfos(commentaire)
+ return listeValeurs, 0
+
+ else: # ce n'est pas un tuple a la mode aster
+ listeValeurs.append(v)
+ indice = indice + 1
+
+ else: # on n'attend pas un complexe
+ listeValeurs = valeurBrute.split(",")
+
+ elif type(valeur) == bytes:
+ listeValeurs = valeur.split(",")
+ else:
+ # listeValeurs.append(valeurBrute)
+ listeValeurs.append(valeur)
+
+ return listeValeurs, 1
+
+
+class SaisieSDCO(object):
+ def LESDCOReturnPressed(self):
+ """
+ Lit le nom donne par l'utilisateur au concept de type CO qui doit être
+ la valeur du MCS courant et stocke cette valeur
+ """
+ self.editor.initModif()
+ anc_val = self.node.item.getValeur()
+ if anc_val != None:
+ # il faut egalement propager la destruction de l'ancien concept
+ self.node.item.deleteValeurCo(valeur=anc_val)
+ # et on force le recalcul des concepts de sortie de l'etape
+ self.node.item.object.etape.getType_produit(force=1)
+ # et le recalcul du contexte
+ self.node.item.object.etape.parent.resetContext()
+ nomConcept = str(self.LESDCO.text())
+ if nomConcept == "":
+ return
+
+ test, commentaire = self.node.item.setValeurCo(nomConcept)
+ if test:
+ commentaire = tr("Valeur du mot-clef enregistree")
+ self.node.updateNodeValid()
+ else:
+ cr = self.node.item.getCr()
+ commentaire = tr("Valeur du mot-clef non autorisee :") + cr.getMessFatal()
+++ /dev/null
-chgt de label_user
-label_integrateur
-chgt de editeur.ini
self.valid = valid
return self.valid
+ def getValid(self, cr="non"):
+ if self.state == "unchanged":
+ return self.valid
+ else:
+ return self.isValid()
+
def verifRegles(self):
"""
Effectue la verification de validite des regles du jeu de commandes
if not old_valid or old_valid != self.valid:
self.initModifUp()
return self.valid
+ def getValid(self):
+ if hasattr(self, "valid"):
+ return self.valid
+ else:
+ self.valid = None
+ return None
typeProto = self.typeProto
intoProto = self.intoProto
cardProto = self.cardProto
+ if self.definition.filtre != None:
+ listePossibles = self.getUserAssdPossible()
+ self.intoProto = IntoProtocol(
+ "into",
+ into=listePossibles,
+ val_min=self.definition.val_min,
+ val_max=self.definition.val_max,
+ )
+ intoProto = self.intoProto
if cr == "oui":
# un cr est demande : on collecte tous les types d'erreur
try:
