From: PASCALE NOYRET Date: Fri, 1 Mar 2024 08:12:59 +0000 (+0100) Subject: etat avant chantier sur les sessionsId X-Git-Tag: V_demo_28_mars_2024~41 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=c7fd0680f205c37bfb4f5644f8c7584447307993;p=tools%2Feficas.git etat avant chantier sur les sessionsId --- diff --git a/Accas/processing/P_JDC.py b/Accas/processing/P_JDC.py index fef390a5..a9b94930 100644 --- a/Accas/processing/P_JDC.py +++ b/Accas/processing/P_JDC.py @@ -60,7 +60,7 @@ NONE = None from Accas.processing.P_utils import SEP def __init__( self, definition=None, procedure=None, cata=None, dicoCataOrdonne=None, - parent=None, nom="SansNom", appliEficas=None, context_ini=None, **args): + parent=None, nom="SansNom", appliEficas=None, editeur = None, context_ini=None, **args): self.procedure = procedure self.definition = definition self.cata = cata diff --git a/Codes/OldCodes/Carmel3D/ajoutGroupe.py b/Codes/OldCodes/Carmel3D/ajoutGroupe.py index 1c6b953f..81364c20 100644 --- a/Codes/OldCodes/Carmel3D/ajoutGroupe.py +++ b/Codes/OldCodes/Carmel3D/ajoutGroupe.py @@ -4,7 +4,7 @@ import re # module interne utilis concept_re=re.compile(r'[a-zA-Z_]\w*$') # nom de maillage valide s'il correspond à un identifiant (variable) Python possible. Basé sur Ihm/I_Etape.py:nomme_sd, qui fait foi -def handleAjoutGroupSansFiltre(editor,listeGroup): +def ajoutGroupeSansFiltre(editor,listeGroup): """code_Carmel temporel : obtention des groupes de maille du maillage selectionne dans Salome Les groupes de mailles ne sont pas filtrés. La creation du MESH_GROUPE n'est donc pas typé. @@ -34,7 +34,7 @@ def handleAjoutGroupSansFiltre(editor,listeGroup): except: raise ValueError, "Ce nom de groupe ("+groupe+") pose un probleme inconnu" -def handleAjoutGroupAvecFiltre(editor,listeGroup): +def ajoutGroupeAvecFiltre(editor,listeGroup): """CARMEL3D : obtention des groupes de maille du maillage selectionne dans Salome Les groupes de mailles sont filtres en utilisant une liste des prefixes autorises pour code Code_Carmel3D, i.e. un nom de groupe de mailles est DIEL_toto_foo par exemple, qui deviendra toto_foo. @@ -168,7 +168,7 @@ def handleAjoutGroupAvecFiltre(editor,listeGroup): except: print u"ERREUR: ce nom de groupe ("+nomReel+") ne peut pas etre utilise car il ne peut pas servir de concept a cause de caractères interdits, e.g. signes moins (-), plus (+), etc." -def handleAjoutGroupFiltre(editor,listeGroup): +def ajoutGroupeFiltre(editor,listeGroup): """CARMEL3D : obtention des groupes de maille du maillage selectionne dans Salome Les groupes de mailles sont filtres en utilisant une liste des prefixes autorises pour code Code_Carmel3D, i.e. un nom de groupe de mailles est DIEL_toto_foo par exemple, qui deviendra toto_foo. @@ -198,6 +198,6 @@ def handleAjoutGroupFiltre(editor,listeGroup): if type_code not in ('frequentiel', 'temporel'): # test de cohérence du type de code raise ValueError("Ce catalogue n'est ni frequentiel ni temporel") if type_code == 'frequentiel': - handleAjoutGroupAvecFiltre(editor, listeGroup) + ajoutGroupeAvecFiltre(editor, listeGroup) if type_code == 'temporel': - handleAjoutGroupSansFiltre(editor, listeGroup) + ajoutGroupeSansFiltre(editor, listeGroup) diff --git a/Codes/OldCodes/PSEN_Eficas/mesScripts.py b/Codes/OldCodes/PSEN_Eficas/mesScripts.py index 987c91d9..3f9f8845 100755 --- a/Codes/OldCodes/PSEN_Eficas/mesScripts.py +++ b/Codes/OldCodes/PSEN_Eficas/mesScripts.py @@ -19,7 +19,7 @@ def import_zone(listeparam,appli) : # simulation de la recuperation zone #import eficasSalome #eficasSalome.runEficas(code='MT',fichier='/home/I29518/test_zone.comm') - appli.editorManager.handleOpen(fichier='/home/A96028/Install_EficasV1/EficasV1/MT/MT_include.comm') + appli.editorManager.openFile(fichier='/home/A96028/Install_EficasV1/EficasV1/MT/MT_include.comm') def import_zone2(listeparam,appli) : editor=listeparam[0] diff --git a/Codes/OldCodes/VirtualPolymer/editor.py.ssVP b/Codes/OldCodes/VirtualPolymer/editor.py.ssVP index d29226fb..1fdf4062 100755 --- a/Codes/OldCodes/VirtualPolymer/editor.py.ssVP +++ b/Codes/OldCodes/VirtualPolymer/editor.py.ssVP @@ -45,7 +45,7 @@ import traceback import convert, generator from Editeur import session from Editeur import comploader -from Editeur import Objecttreeitem +from Editeur import objecttreeitem from desBaseWidget import Ui_baseWidget from InterfaceQT4.monViewTexte import ViewText from monWidgetCreeParam import MonWidgetCreeParam @@ -225,7 +225,7 @@ class JDCEditor(Ui_baseWidget,QWidget): if (self.appliEficas.ssIhm == False) : QMessageBox.critical( self, tr("Erreur fatale au chargement d'un fichier"), txt_exception) else: comploader.charger_composants("QT") - jdc_item=Objecttreeitem.make_objecttreeitem( self, "nom", self.jdc ) + jdc_item=objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc ) if (not self.jdc.isvalid()) and (not self.nouveau) and (self.appliEficas.ssIhm == False): self.viewJdcRapport() diff --git a/Editeur/editor.py b/Editeur/editor.py index ec87b14c..7c5836ae 100755 --- a/Editeur/editor.py +++ b/Editeur/editor.py @@ -26,6 +26,7 @@ import traceback import Accas.IO.reader as reader import Accas.IO.writer as writer +from uuid import uuid1 from Accas.extensions.eficas_exception import EficasException Dictextensions = {"MAP": ".map", "TELEMAC": ".cas"} @@ -56,6 +57,9 @@ class Editor: self.dicoNouveauxFact = {} self.dict_reels = {} self.liste_simp_reel = [] + self.idUnique = uuid1().hex + self.appliEficas.editorManager.dictEditors[self.idUnique]=self + # ces attributs sont mis a jour par definitCode appelee par newEditor @@ -234,6 +238,7 @@ class Editor: dicoCataOrdonne=self.readercata.dicoCataOrdonne, nom=jdcName, repMat=self.maConfiguration.repMat, + editeur=self ) self.modified = False self.monJDCReader = monJDCReader @@ -257,6 +262,7 @@ class Editor: cata=self.readercata.cata, dicoCataOrdonne=self.readercata.dicoCataOrdonne, repMat=self.maConfiguration.repMat, + editeur=self ) jdc.lang = self.appliEficas.langue @@ -285,6 +291,7 @@ class Editor: cata=self.readercata.cata, dicoCataOrdonne=self.readercata.dicoCataOrdonne, repMat=self.maConfiguration.repMat, + editeur=self ) jaux.editor = self jaux.analyse() @@ -296,6 +303,7 @@ class Editor: dicoCataOrdonne=self.readercata.dicoCataOrdonne, jdc_pere=jaux, repMat=self.maConfiguration.repMat, + editeur=self ) J.editor = self J.analyse() diff --git a/Editeur/eficas_appli.py b/Editeur/eficas_appli.py index 27476bc4..ee3dc79a 100755 --- a/Editeur/eficas_appli.py +++ b/Editeur/eficas_appli.py @@ -153,7 +153,7 @@ class EficasAppli: #-------------------------- def getEditorById(self,id): #-------------------------- - return self.editorManager.getEditorById(self,id) + return self.editorManager.getEditorById(id) #---------------------------------- def setCurrentEditorById(self,id): diff --git a/InterfaceGUI/Common/comploader.py b/InterfaceGUI/Common/comploader.py new file mode 100644 index 00000000..e8ffe05e --- /dev/null +++ b/InterfaceGUI/Common/comploader.py @@ -0,0 +1,105 @@ +# -*- 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 +# +""" + Module de chargement des composants et de mapping des objets du processing + Accas vers les items d'EFICAS + + - composants : dictionnaire de stockage des relations entre types + d'objet du processing et types d'item + - chargerComposants() : fonction de chargement des composants. Retourne + le dictionnaire composants. + - gettreeitem(object) -> type d'item : fonction qui retourne un type + d'item correspondant au type de l'objet processing fourni. + - makeObjecttreeitem(appliEficas,labeltext, object, setFunction=None) -> item : fonction qui retourne un item + correspondant a l'objet processing fourni. +""" +import os, glob, types + +# Dictionnaire {object : item} permettant d'associer un item a un object +# Ce dictionnaire est renseigne par la methode chargerComposants +composants = {} + + +def chargerComposants(GUIPath): + """ + Cette fonction a pour but de charger tous les modules composants graphiques + (fichiers compo*.py dans le meme repertoire que ce module ) + et de remplir le dictionnaire composants utilise par makeObjecttreeitem + """ + debug = 0 + ici=os.path.dirname(os.path.abspath(__file__)) + if debug : print ('GUIPath') + repertoire = os.path.join(ici,"../..", "InterfaceGUI",GUIPath) + if debug : print ('repertoire', repertoire) + package = 'InterfaceGUI.'+GUIPath + listfich = glob.glob(os.path.join(repertoire, "compo*.py")) + if debug : print ('listfich', listfich) + for fichier in listfich: + if debug : print (fichier) + m = os.path.basename(fichier)[:-3] + module = __import__(package, globals(), locals(), [m]) + module = getattr(module, m) + composants[module.objet] = module.treeitem + if debug: + print("fin chargerComposants, composants : ", composants) + return composants + + +def gettreeitem(object): + """ + Cette fonction retourne la classe item associee a l'objet object. + Cette classe item depend bien sur de la nature de object, d'ou + l'interrogation du dictionnaire composants + """ + # Si la definition de l'objet a un attribut itemeditor, il indique + # la classe a utiliser pour l'item + try: + return object.definition.itemeditor + except: + pass + + try: + itemtype = composants[object.__class__] + return itemtype + except: + pass + + # Puis une eventuelle classe heritee (aleatoire car sans ordre) + for e in list(composants.keys()): + if e and isinstance(object, e): + itemtype = composants[e] + return itemtype + + # Si on n'a rien trouve dans les composants on utilise l'objet par defaut + # fonctionnalite qui n est pas developpee : composants[None] n existe pas + itemtype = composants[None] + return itemtype + + +def makeObjecttreeitem(appliEficas, labeltext, object, setFunction=None): + """ + Cette fonction permet de construire et de retourner un objet + de type item associe a l'object passe en argument. + """ + debug = 0 + if debug: + print(appliEficas, labeltext, object, setFunction) + c = gettreeitem(object) + return c(appliEficas, labeltext, object, setFunction) diff --git a/InterfaceGUI/Common/jdc_treeItem_commun.py b/InterfaceGUI/Common/jdc_treeItem_commun.py new file mode 100644 index 00000000..c2ff3eb3 --- /dev/null +++ b/InterfaceGUI/Common/jdc_treeItem_commun.py @@ -0,0 +1,113 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2024 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +from InterfaceGUI.Common import objecttreeitem +from Accas.extensions.eficas_translation import tr + + +class JDCTreeItemCommun(objecttreeitem.ObjectTreeItem): + + def isExpandable(self): + return 1 + + def getText(self): + return " " + + def getLabelText(self): + # None --> fonte et couleur par defaut + return tr(self.object.nom), None, None + + def getJdc(self): + """ + Retourne l'objet pointe par self + """ + return self.object + + def getIconName(self): + if self.object.isValid(): + return "ast-green-square" + else: + return "ast-red-square" + + # def keys(self): + # if self.object.etapes_niveaux != []: + # return range(len(self.object.etapes_niveaux)) + # else: + # return range(len(self.object.etapes)) + + def addItem(self, name, pos): + cmd = self._object.addEntite(name, pos) + return cmd + + def suppItem(self, item): + # item = item de l'ETAPE a supprimer du JDC + # item.getObject() = ETAPE ou COMMENTAIRE + # self.object = JDC + + itemobject = item.getObject() + if self.object.suppEntite(itemobject): + if itemobject.nature == "COMMENTAIRE": + message = tr("Commentaire supprime") + else: + message = tr("Commande %s supprimee", itemobject.nom) + return 1, message + else: + message = tr("Pb interne : impossible de supprimer cet objet") + return 0, message + + def getSubList(self): + """ + Retourne la liste des items fils de l'item jdc. + Cette liste est conservee et mise a jour a chaque appel + """ + if self.object.etapes_niveaux != []: + liste = self.object.etapes_niveaux + else: + liste = self.object.etapes + sublist = [None] * len(liste) + # suppression des items lies aux objets disparus + for item in self.sublist: + old_obj = item.getObject() + if old_obj in liste: + pos = liste.index(old_obj) + sublist[pos] = item + else: + pass # objets supprimes ignores + # ajout des items lies aux nouveaux objets + pos = 0 + for obj in liste: + if sublist[pos] is None: + # nouvel objet : on cree un nouvel item + item = self.makeObjecttreeitem(self.appliEficas, obj.nom + " : ", obj) + sublist[pos] = item + pos = pos + 1 + + self.sublist = sublist + return self.sublist + + def getLNomsEtapes(self): + """Retourne la liste des noms des etapes de self.object""" + return self.object.getLNomsEtapes() + + def getListeCmd(self): + listeCmd = self.object.niveau.definition.getListeCmd() + return listeCmd + + diff --git a/InterfaceGUI/Common/objecttreeitem.py b/InterfaceGUI/Common/objecttreeitem.py new file mode 100644 index 00000000..b77b7049 --- /dev/null +++ b/InterfaceGUI/Common/objecttreeitem.py @@ -0,0 +1,553 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2024 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +""" +""" +from builtins import str +from builtins import object +import types, os, sys +from copy import copy, deepcopy +from uuid import uuid1 + +# import du chargeur de composants +from InterfaceGUI.Common.comploader import makeObjecttreeitem +from Accas.accessor import CONNECTOR +from Accas.extensions.eficas_translation import tr +from Accas.extensions.eficas_exception import EficasException + +from reprlib import Repr + +myrepr = Repr() +myrepr.maxstring = 100 +myrepr.maxother = 100 + + +class TreeItem(object): + + """Abstract class representing tree items. + + Methods should typically be overridden, otherwise a default action + is used. + + """ + + # itemNode est une factory qui doit retourner un objet de la classe Node + # ou derive de cette classe. + # Le widget arbre utilisera cet objet comme noeud associe au tree item. + # Par defaut, utilise la classe Node de base + # La signature de la factory est la suivante : + # itemNode(treeOrNode,item,command,rmenu) + # ou treeOrNode est le noeud parent, item est l'item associe + # command est une fonction python appelee sur selection graphique + # du noeud et rmenu est une fonction python appelee sur click droit sur le noeud + itemNode = None + + def __init__(self): + """Constructor. Do whatever you need to do.""" + + def getText(self): + """Return text string to display.""" + + def getLabelText(self): + """Return label text string to display in front of text (if any).""" + + expandable = None + + def _isExpandable(self): + if self.expandable is None: + self.expandable = self.isExpandable() + return self.expandable + + def isExpandable(self): + """Return whether there are subitems.""" + return 1 + + def _getSubList(self): + """Do not override! Called by TreeNode.""" + if not self.isExpandable(): + return [] + sublist = self.getSubList() + if not sublist: + self.expandable = 0 + return sublist + + def IsEditable(self): + """Return whether the item's text may be edited.""" + pass + + def SetText(self, text): + """Change the item's text (if it is editable).""" + pass + + def getIconName(self): + """Return name of icon to be displayed normally.""" + pass + + def getSelectedIconName(self): + """Return name of icon to be displayed when selected.""" + pass + + def getSubList(self): + """Return list of items forming sublist.""" + pass + + def onDoubleClick(self): + """Called on a double-click on the item.""" + pass + + +class Delegate(object): + def __init__(self, delegate=None): + self.object = delegate + self.__cache = {} + + def setDelegate(self, delegate): + self.resetcache() + self.object = delegate + + def getDelegate(self): + return self.object + + def __getattr__(self, name): + attr = getattr(self.object, name) # May raise AttributeError + setattr(self, name, attr) + self.__cache[name] = attr + return attr + + def resetcache(self): + for key in list(self.__cache.keys()): + try: + delattr(self, key) + except AttributeError: + pass + self.__cache.clear() + + def cachereport(self): + keys = list(self.__cache.keys()) + keys.sort() + # print keys + + +class ObjectTreeItem(TreeItem, Delegate): + def __init__(self, appliEficas, labeltext, object, setFunction=None): + self.labeltext = labeltext + self.appliEficas = appliEficas + # L'objet delegue est stocke dans l'attribut object + # L'objet associe a l'item est stocke dans l'attribut _object + # Il peut etre obtenu par appel a la methode getObject + # Attention : le delegue peut etre different de l'objet associe (MCLIST) + # Dans le cas d'une MCListe de longueur 1, l'objet associe est la MCListe + # et l'objet delegue est le MCFACT (object = _object.data[0]) + Delegate.__init__(self, object) + # On cache l'objet initial (pour destruction eventuelle + # ulterieure) + self._object = object + self.setFunction = setFunction + self.expandable = 1 + self.sublist = [] + self.init() + + + # La partie suivante ne sert que pour le Web + # on met le meme id au noeud et a l objet + # utile pour les MCList + if hasattr(object, "idUnique"): + self.idUnique = object.idUnique + else: + self.idUnique = uuid1().hex + + if self._object.nature == "MCList" and len(self._object.data) == 1: + # pour les suppressions on met le meme id a l objet et a la liste + self._object.data[0].idUnique = self.idUnique + self._object.idUnique = self._object.data[0].idUnique + #if hasattr(self.appliEficas, "dicoIdNode"): + # self.appliEficas.dicoIdNode[self._object.data[0].idUnique] = self + #22 fevrier. pourquoi ? + self.idUnique = 0 + return + + self._object.idUnique = self.idUnique + #print (self, self._object.nom, self.idUnique) + #if hasattr(self.appliEficas, "dicoIdNode") and self.idUnique: + # self.appliEficas.dicoIdNode[self.idUnique] = self + + def init(self): + return + + def getObject(self): + return self._object + + def connect(self, channel, callable, args): + """Connecte la fonction callable (avec arguments args) a l'item self sur le + canal channel + """ + # print self,channel,callable,args + CONNECTOR.Connect(self._object, channel, callable, args) + CONNECTOR.Connect(self.object, channel, callable, args) + + def copy(self): + """ + Cree un item copie de self + """ + object = self._object.copy() + appliEficas = copy(self.appliEficas) + labeltext = copy(self.labeltext) + fonction = deepcopy(self.setFunction) + item = makeObjecttreeitem(appliEficas, labeltext, object, fonction) + return item + + def isActif(self): + if hasattr(self.object, "actif"): + return self.object.actif + else: + return 1 + + def update(self, item): + """ + Met a jour l'item courant a partir d'un autre item passe en argument + Ne fait rien par defaut + """ + pass + + def getLabelText(self): + """Retourne 3 valeurs : + - le texte a afficher dans le noeud representant l'item + - la fonte dans laquelle afficher ce texte + - la couleur du texte + """ + # None --> fonte et couleur par defaut + return tr(self.labeltext), None, None + + def getNature(self): + """ + Retourne la nature de l'item et de l'objet + """ + return self.object.nature + + def getRegles(self): + """retourne les regles de l'objet pointe par self""" + return self.object.getRegles() + + def getListeMcPresents(self): + """Retourne la liste des mots-cles fils de l'objet pointe par self""" + return self.object.listeMcPresents() + + def getVal(self): + """Retourne le nom de la valeur de l'objet pointe par self dans le cas + ou celle-ci est un objet (ASSD)""" + return self.object.getVal() + + def get_definition(self): + """ + Retourne l'objet definition de l'objet pointe par self + """ + return self.object.definition + + def getListeMcOrdonnee(self, liste, dico): + """retourne la liste ordonnee (suivant le catalogue) brute des mots-cles + d'une entite composee dont le chemin complet est donne sous forme + d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... + il faut encore rearranger cette liste (certains mots-cles deja + presents ne doivent plus etre proposes, regles ...)""" + return self.object.getListeMcOrdonnee(liste, dico) + + def getListeMcOrdonneeBrute(self, liste, dico): + """ + retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles + d'une entite composee dont le chemin complet est donne sous forme + d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... + """ + return self.object.getListeMcOrdonneeBrute(liste, dico) + + def getGenealogie(self): + """ + Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC ou ETAPE) + de l'objet pointe par self + """ + return self.object.getGenealogie() + + def getIndexChild(self, nom_fils): + """ + Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils + Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter + le nouveau mot-cle + """ + return self.object.getIndexChild(nom_fils) + + def getIndexChild_old(self, nom_fils): + """ + Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils + Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter + le nouveau mot-cle + """ + liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute( + self.getGenealogie(), self.getJdc().dicoCataOrdonne + ) + liste_noms_mc_presents = self.object.listeMcPresents() + l = [] + for nom in liste_noms_mc_ordonnee: + if nom in liste_noms_mc_presents or nom == nom_fils: + l.append(nom) + # l contient les anciens mots-cles + le nouveau dans l'ordre + return l.index(nom_fils) + + def appendChild(self, name, pos=None): + """ + Permet d'ajouter un item fils a self + """ + if pos == "first": + index = 0 + elif pos == "last": + index = len(self.listeMcPresents()) + elif type(pos) == int: + # la position est fixee + index = pos + # elif type(pos) == types.InstanceType: + elif type(pos) == object: + # pos est un item. Il faut inserer name apres pos + index = self.getIndex(pos) + 1 + # elif type(name) == types.InstanceType: + elif type(name) == object: + index = self.getIndexChild(name.nom) + else: + index = self.getIndexChild(name) + return self.addobject(name, index) + + def appendBrother(self, name, pos="after"): + """ + Permet d'ajouter un frere a self + par defaut on l'ajoute apres self + """ + index = self._object.parent.getIndex(self.getObject()) + if pos == "before": + index = index + elif pos == "after": + index = index + 1 + else: + print((tr("%d n'est pas un index valide pour appendBrother", pos))) + return + return self.parent.addobject(name, index) + + def getCopieObjet(self): + """Retourne une copie de l'objet pointe par self""" + return self.object.copy() + + def getPosition(self): + """Retourne la valeur de l'attribut position de l'objet pointe par self""" + definition = self.get_definition() + try: + return getattr(definition, "position") + except AttributeError: + return "local" + + def getNom(self): + """Retourne le nom de l'objet pointe par self""" + return self.object.nom + + def getJdc(self): + """Retourne le jdc auquel appartient l'objet pointe par self""" + return self.object.jdc + + def getValeur(self): + """Retourne la valeur de l'objet pointe par self""" + return self.object.valeur + + def getCr(self): + """Retourne le compte-rendu CR de self""" + return self.object.report() + + def getObjetCommentarise(self): + """ + Cette methode retourne un objet commentarise + representatif de self.object + --> a surcharger par les differents items + """ + raise EficasException( + "MESSAGE AU DEVELOPPEUR : il faut \ + surcharger la methode getObjetCommentarise() \ + pour la classe %s", + self.__class__.__name__, + ) + + def isValid(self): + """Retourne 1 si l'objet pointe par self est valide, 0 sinon""" + return self.object.isValid() + + def isCopiable(self): + """ + Retourne 1 si l'objet est copiable, 0 sinon + Par defaut retourne 0 + """ + return 0 + + def getMcPresents(self): + """Retourne le dictionnaire des mots-cles presents de l'objet pointe par self""" + return self.object.dictMcPresents() + + def verifConditionRegles(self, l_mc_presents): + return self.object.verifConditionRegles(l_mc_presents) + + def getFr(self): + """Retourne le fr de l'objet pointe par self""" + try: + return self.object.getFr() + except: + return "" + + def getDocu(self): + """Retourne la cle de doc de l'objet pointe par self""" + return self.object.getDocu() + + def setValeur(self, new_valeur): + """Remplace la valeur de l'objet pointe par self par new_valeur""" + return self.object.setValeur(new_valeur) + + def getText(self): + return myrepr.repr(self.object) + + def getIconName(self): + if not self.isExpandable(): + return "python" + + def IsEditable(self): + return self.setFunction is not None + + def SetText(self, text): + try: + value = eval(text) + self.setFunction(value) + except: + pass + + def isExpandable(self): + return 1 + + def getSubList(self): + keys = dir(self.object) + sublist = [] + for key in keys: + try: + value = getattr(self.object, key) + except AttributeError: + continue + item = makeObjecttreeitem( + self.appliEficas, + str(key) + " =", + value, + lambda value, key=key, object=self.object: setattr(object, key, value), + ) + sublist.append(item) + return sublist + + # a piori inutile PN 06 11 17 + # def wait_fichier_init(self): + """ Retourne 1 si l'object pointe par self attend un fichier d'initialisation + (ex: macros POURSUITE et INCLUDE de Code_Aster), 0 SINON """ + + # return self.object.definition.fichier_ini + + def makeObjecttreeitem(self, appliEficas, labeltext, object, setFunction=None): + """ + Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet + de type item associe a l'object passe en argument. + """ + return makeObjecttreeitem(appliEficas, labeltext, object, setFunction) + + # def __del__(self): + # print "__del__",self + + +class AtomicObjectTreeItem(ObjectTreeItem): + def isExpandable(self): + return 0 + + +class SequenceTreeItem(ObjectTreeItem): + def isExpandable(self): + return len(self._object) > 0 + + def __len__(self): + return len(self._object) + + def keys(self): + return list(range(len(self._object))) + + def getIconName(self): + if self._object.isValid(): + return "ast-green-los" + elif self._object.isOblig(): + return "ast-red-los" + else: + return "ast-yel-los" + + def ajoutPossible(self): + return self._object.ajoutPossible() + + def getIndex(self, child): + """Retourne le numero de child dans la liste des enfants de self""" + return self._object.getIndex(child.getObject()) + + def getText(self): + return " " + + def addItem(self, obj, pos): + self._object.insert(pos, obj) + item = self.makeObjecttreeitem(self.appliEficas, obj.nom + ":", obj) + return item + + def suppItem(self, item): + try: + self._object.remove(item.getObject()) + # la liste peut etre retournee vide ! + message = "Mot-clef " + item.getObject().nom + " supprime" + self.appliEficas.afficheMessages(message) + return 1 + except: + return 0 + + def getSubList(self): + isublist = iter(self.sublist) + liste = self._object.data + iliste = iter(liste) + self.sublist = [] + + while 1: + old_obj = obj = None + for item in isublist: + old_obj = item.getObject() + if old_obj in liste: + break + + for obj in iliste: + if obj is old_obj: + break + + # nouvel objet : on cree un nouvel item + def setFunction(value, object=obj): + object = value + + it = self.makeObjecttreeitem( + self.appliEficas, obj.nom + " : ", obj, setFunction + ) + self.sublist.append(it) + if old_obj is None and obj is None: + break + if old_obj is obj: + self.sublist.append(item) + return self.sublist diff --git a/InterfaceGUI/Common/param_treeItem_commun.py b/InterfaceGUI/Common/param_treeItem_commun.py new file mode 100644 index 00000000..8eaac1a1 --- /dev/null +++ b/InterfaceGUI/Common/param_treeItem_commun.py @@ -0,0 +1,126 @@ +# -*- coding: utf-8 -*- +# Copyright (C) 2007-2024 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +""" + Ce module contient les classes permettant de definir les objets graphiques + representant un objet de type PARAMETRE, cad le panneau et l'item de l'arbre + d'EFICAS +""" +# import modules Python +import types +from Accas.extensions.eficas_translation import tr +from InterfaceGUI.Common import objecttreeitem + +class PARAMTreeItemCommun(objecttreeitem.ObjectTreeItem): + """ + Classe servant a definir l'item porte par le noeud de l'arbre d'EFICAS + qui represente le PARAMETRE + """ + + 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") + diff --git a/InterfaceGUI/Common/politiquesValidation.py b/InterfaceGUI/Common/politiquesValidation.py new file mode 100644 index 00000000..043c6409 --- /dev/null +++ b/InterfaceGUI/Common/politiquesValidation.py @@ -0,0 +1,333 @@ +# -*- 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 Accas.extensions.eficas_translation 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__(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") + 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 diff --git a/InterfaceGUI/Common/simp_treeItem_commun.py b/InterfaceGUI/Common/simp_treeItem_commun.py new file mode 100644 index 00000000..e700c25a --- /dev/null +++ b/InterfaceGUI/Common/simp_treeItem_commun.py @@ -0,0 +1,602 @@ +# -*- coding: iso-8859-1 -*- +# Copyright (C) 2007-2024 EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +# Modules Python +import types, os + +from copy import copy, deepcopy +import traceback +from InterfaceGUI.QT5 import typeNode + +# Modules Eficas +from InterfaceGUI.Common import objecttreeitem +from Accas import SalomeEntry + +class SIMPTreeItemCommun(objecttreeitem.AtomicObjectTreeItem): + def init(self): + self.expandable = 0 + + # ----------------------------------------------- + # + # Methodes liees aux informations sur le Panel + # ou au mot-clef simple + # + # ----------------------------------------------- + # isList + # hasInto + # getMinMax + # getMultiplicite + # getIntervalle + # getListeValeurs + # getListePossible + + def isList(self): + """ + Cette methode indique si le mot cle simple attend une liste (valeur de retour 1) + ou s'il n'en attend pas (valeur de retour 0) + + Deux cas principaux peuvent se presenter : avec validateurs ou bien sans. + Dans le cas sans validateur, l'information est donnee par l'attribut max + de la definition du mot cle. + Dans le cas avec validateur, il faut combiner l'information precedente avec + celle issue de l'appel de la methode isList sur le validateur.On utilisera + l'operateur ET pour effectuer cette combinaison (AndVal). + """ + is_a_list = 0 + min, max = self.getMinMax() + assert min <= max + if max > 1: + is_a_list = 1 + # Dans le cas avec validateurs, pour que le mot cle soit considere + # comme acceptant une liste, il faut que max soit superieur a 1 + # ET que la methode isList du validateur retourne 1. Dans les autres cas + # on retournera 0 (n'attend pas de liste) + if self.definition.validators: + is_a_list = self.definition.validators.isList() * is_a_list + return is_a_list + + def isListSansOrdreNiDoublon(self): + if self.definition.homo=="SansOrdreNiDoublon" : return 1 + return 0 + + def hasInto(self): + """ + Cette methode indique si le mot cle simple propose un choix (valeur de retour 1) + ou s'il n'en propose pas (valeur de retour 0) + + Deux cas principaux peuvent se presenter : avec validateurs ou bien sans. + Dans le cas sans validateur, l'information est donnee par l'attribut into + de la definition du mot cle. + Dans le cas avec validateurs, pour que le mot cle soit considere + comme proposant un choix, il faut que into soit present OU + que la methode hasInto du validateur retourne 1. Dans les autres cas + on retournera 0 (ne propose pas de choix) + """ + has_an_into = 0 + if self.definition.into: + has_an_into = 1 + elif self.definition.validators: + has_an_into = self.definition.validators.hasInto() + return has_an_into + + def hasIntoSug(self): + if self.definition.intoSug: return 1 + return 0 + + def getMinMax(self): + """Retourne les valeurs min et max de la definition de object""" + return self.object.getMinMax() + + def getMultiplicite(self): + """A preciser. + Retourne la multiplicite des valeurs affectees a l'objet + represente par l'item. Pour le moment retourne invariablement 1. + """ + return 1 + + def getIntervalle(self): + """ + Retourne le domaine de valeur attendu par l'objet represente + par l'item. + """ + return self.object.getintervalle() + + def getListeValeurs(self): + """Retourne la liste des valeurs de object""" + valeurs = self.object.getListeValeurs() + try: + if "R" in self.object.definition.type: + clef = self.object.getNomConcept() + if clef in self.appliEficas.dict_reels: + if type(valeurs) == tuple: + valeurs_reelles = [] + for val in valeurs: + if val in self.appliEficas.dict_reels[clef]: + valeurs_reelles.append(self.appliEficas.dict_reels[clef][val]) + else: + valeurs_reelles.append(val) + else: + if valeurs in self.appliEficas.dict_reels[clef]: + valeurs_reelles = self.appliEficas.dict_reels[clef][valeurs] + valeurs = valeurs_reelles + except: + pass + return valeurs + + def getListePossible(self, listeActuelle=[]): + if hasattr(self.definition.validators, "into"): + valeurspossibles = self.definition.validators.into + else: + valeurspossibles = self.get_definition().into + + if listeActuelle==[] : return valeurspossibles + + # On ne garde que les items valides + listevalideitem = [] + if type(valeurspossibles) in (list, tuple): + pass + else: + valeurspossibles = (valeurspossibles,) + for item in valeurspossibles: + encorevalide = self.valideItem(item) + if encorevalide: + listevalideitem.append(item) + + # on ne garde que les choix possibles qui passent le test de valideListePartielle + listevalideliste = [] + for item in listevalideitem: + encorevalide = self.valideListePartielle(item, listeActuelle) + if encorevalide: + listevalideliste.append(item) + # print listevalideliste + return listevalideliste + + def getListePossibleAvecSug(self, listeActuelle=[]): + if hasattr(self.definition,'intoSug'): + valeurspossibles = self.definition.intoSug + else: + return listeActuelle + + if listeActuelle==[] : return valeurspossibles + valeurspossibles = valeurspossibles + listeActuelle + + # On ne garde que les items valides + listevalideitem = [] + if type(valeurspossibles) in (list, tuple): + pass + else: + valeurspossibles = (valeurspossibles,) + for item in valeurspossibles: + encorevalide = self.valideItem(item) + if encorevalide: + listevalideitem.append(item) + + # on ne garde que les choix possibles qui passent le test de valideListePartielle + listevalideliste = [] + for item in listevalideitem: + encorevalide = self.valideListePartielle(item, listeActuelle) + if encorevalide: + listevalideliste.append(item) + return listevalideliste + + def getListeParamPossible(self): + liste_param = [] + l1, l2 = self.jdc.getParametresFonctionsAvantEtape(self.getEtape()) + for param in self.object.jdc.params: + if param.nom not in l1: + continue + encorevalide = self.valideItem(param.valeur) + if encorevalide: + type_param = param.valeur.__class__.__name__ + for typ in self.definition.type: + if typ == "R": + liste_param.append(param) + if typ == "I" and type_param == "int": + liste_param.append(param) + if typ == "TXM" and type_param == "str": + liste_param.append(repr(param)) + if ("grma" in repr(typ)) and type_param == "str": + liste_param.append(param.nom) + return liste_param + + # -------------------------------------------------- + # + # Methodes liees a la validite des valeurs saisies + # + # --------------------------------------------------- + # valideItem + # valideListePartielle + # valideListeComplete + # infoErreurItem + # infoErreurListe + # isInIntervalle + # isValid + + def valideItem(self, item): + """ + La validation est realisee directement par l'objet + """ + return self.object.valideItem(item) + + def valideListePartielle(self, item, listecourante): + # On protege la liste en entree en la copiant + valeur = list(listecourante) + if item : valeur.append(item) + return self.object.validValeurPartielle(valeur) + + def valideListeComplete(self, valeur): + return self.object.validValeur(valeur) + + def infoErreurItem(self): + commentaire = "" + if self.definition.validators: + commentaire = self.definition.validators.infoErreurItem() + return commentaire + + def aide(self): + commentaire = "" + if self.definition.validators: + commentaire = self.definition.validators.aide() + return commentaire + + def infoErreurListe(self): + commentaire = "" + if self.definition.validators: + commentaire = self.definition.validators.infoErreurListe() + return commentaire + + def isInIntervalle(self, valeur): + """ + Retourne 1 si la valeur est dans l'intervalle permis par + l'objet represente par l'item. + """ + return self.valideItem(valeur) + + def isValid(self): + valide = self.object.isValid() + return valide + + # -------------------------------------------------- + # + # Autres ... + # + # --------------------------------------------------- + # getIconName + # getText + # setValeurCo + # getSdAvantDuBonType + + def getIconName(self): + if self.appliEficas.maConfiguration.differencieSiDefaut and self.isValid(): + if self.object.definition.defaut != None: + if self.object.valeur == self.object.definition.defaut : return "ast-green-dark-ball" + if self.object.definition.max > 1 and list(self.object.valeur) == list(self.object.definition.defaut) : return "ast-green-dark-ball" + return "ast-green-ball" + elif self.isValid(): + return "ast-green-ball" + elif self.object.isOblig(): + return "ast-red-ball" + else: + return "ast-yel-ball" + + def getText(self): + """ + Classe SIMPTreeItem + Retourne le texte a afficher dans l'arbre representant la valeur de l'objet + pointe par self + """ + if ( + self.waitUserAssdMultiple() + or self.object.waitUserAssd() + or self.object.waitAssd() + ): + return self.object.valeur + # if self.object.valeur != None : return self.object.valeur.nom + # else : return "" + text = self.object.getText() + if text == None : text="" + return text + + def setValeurCo(self, nomCo): + """ + Affecte au MCS pointe par self l'objet de type CO et de nom nom_co + """ + ret = self.object.setValeurCo(nomCo) + # print "setValeurCo",ret + return ret + + def getSdAvantDuBonType(self): + """ + Retourne la liste des noms des SD presentes avant l'etape qui contient + le MCS pointe par self et du type requis par ce MCS + """ + # A changer pour tenir compte des UserASSDMultiple + # ici on passe par parent pour avoir le bon type + # if self.waitUserAssdMultiple() : + # l=self.object.parent.getSdCreeParObjetAvecFiltre(self.object) + # return l + if self.waitUserAssdMultiple(): + l = self.object.getUserAssdPossible() + return l + a=self.object.etape.parent.getSdAvantDuBonType(self.object.etape,self.object.definition.type) + if self.waitUserAssd() : l=self.jdc.getSdCreeParObjet(self.object.definition.type) + else :l=[] + return a + l + + def getSdAvantDuBonTypePourTypeDeBase(self): + a=self.object.jdc.getSdAvantDuBonTypePourTypeDe_Base(self.object.etape,"LASSD") + return a + + def deleteValeurCo(self, valeur=None): + """ + Supprime la valeur du mot cle (de type CO) + il faut propager la destruction aux autres etapes + """ + if not valeur : valeur=self.object.valeur + # XXX faut il vraiment appeler delSdprod ??? + # self.object.etape.parent.delSdprod(valeur) + self.object.etape.parent.deleteConcept(valeur) + + # ----------------------------------------------- + # + # Methodes liees au type de l objet attendu + # + # ----------------------------------------------- + # waitCo + # waitGeom + # waitComplex + # waitReel + # waitAssd + # getType + + def waitCo(self): + """ + Methode booleenne qui retourne 1 si l'objet pointe par self + attend un objet de type ASSD qui n'existe pas encore (type CO()), + 0 sinon + """ + return self.object.waitCo() + + def waitFichier(self): + maDefinition = self.object.definition + try: + if ("Repertoire" in maDefinition.type[0]) or ( + "Fichier" in maDefinition.type[0] + ): + return 1 + except: + return 0 + + def waitGeom(self): + """ + Methode booleenne qui retourne 1 si l'objet pointe par self + attend un objet GEOM, 0 sinon + """ + return self.object.waitGeom() + + def waitTxm(self): + return self.object.waitTxm() + + def waitComplex(self): + """Methode booleenne qui retourne 1 si l'objet pointe par self + attend un complexe, 0 sinon""" + if "C" in self.object.definition.type: + return 1 + else: + return 0 + + def waitReel(self): + """Methode booleenne qui retourne 1 si l'objet pointe par self + attend un reel, 0 sinon""" + if "R" in self.object.definition.type: + return 1 + else: + return 0 + + def waitTuple(self): + return self.object.waitTuple() + + def waitDate(self): + """Methode booleenne qui retourne 1 si l'objet pointe par self + attend un reel, 0 sinon""" + if "DateHHMMAAAA" in self.object.definition.type: + return 1 + else: + return 0 + + def waitHeure(self): + """Methode booleenne qui retourne 1 si l'objet pointe par self + attend un reel, 0 sinon""" + if "HeureHHMMSS" in self.object.definition.type: + return 1 + else: + return 0 + + def waitTuple(self): + """Methode booleenne qui retourne 1 si l'objet pointe par self + attend un Tuple, 0 sinon""" + for ss_type in self.object.definition.type: + if repr(ss_type).find("Tuple") != -1: + return 1 + return 0 + + def waitMatrice(self): + """Methode booleenne qui retourne 1 si l'objet pointe par self + attend un Tuple, 0 sinon""" + # il faut trouver autre chose que ce find!!! + for ss_type in self.object.definition.type: + # if repr(ss_type).find('Matrice') != -1 : + if hasattr(ss_type, "typElt"): + return 1 + return 0 + + def waitAssd(self): + """Methode booleenne qui retourne 1 si l'objet pointe par self + attend un objet de type ASSD ou derive, 0 sinon""" + return self.object.waitAssd() + + def waitAssdOrTypeBase(self): + boo = 0 + if len(self.object.definition.type) > 1: + if self.waitReel(): + boo = 1 + if "I" in self.object.definition.type: + boo = 1 + return boo + + def waitSalome(self): + monType = self.object.definition.type[0] + if 'grma' in repr(monType) : return True + if 'grno' in repr(monType) : return True + try: + if issubclass(monType, SalomeEntry) : return True + except: + pass + return False + + def getType(self): + """ + Retourne le type de valeur attendu par l'objet represente par l'item. + """ + return self.object.getType() + + # ----------------------------------------------------- + # + # Methodes liees a l evaluation de la valeur saisie + # + # ----------------------------------------------------- + # evalValeur + # evalValeurItem + # isCO + # traiteReel + + def evalValeur(self, valeur): + """Lance l'interpretation de 'valeur' (chaine de caracteres) comme valeur de self : + - retourne l'objet associe si on a pu interpreter (entier, reel, ASSD,...) + - retourne 'valeur' (chaine de caracteres) sinon + """ + newvaleur = self.evalVal(valeur) + return newvaleur, 1 + + def evalValeurItem(self, valeur): + """Lance l'interpretation de 'valeur' qui doit ne pas etre un tuple + - va retourner la valeur de retour et la validite + selon le type de l objet attendu + - traite les reels et les parametres + """ + # print "evalValeurItem",valeur + if valeur == None or valeur == "": + return None, 0 + validite = 1 + if self.waitReel(): + valeurinter = self.traiteReel(valeur) + if valeurinter != None: + valeurretour, validite = self.object.evalValeur(valeurinter) + else: + valeurretour, validite = self.object.evalValeur(valeur) + elif self.waitGeom(): + valeurretour, validite = valeur, 1 + else: + valeurretour, validite = self.object.evalValeur(valeur) + + if validite == 0: + if (type(valeur) == bytes or type(valeur) == str) and self.object.waitTxm(): + essai_valeur = "'" + valeur + "'" + valeurretour, validite = self.object.evalValeur(essai_valeur) + + if hasattr(valeurretour, "__class__"): + # if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'): + if valeurretour.__class__.__name__ in ("PARAMETRE",): + validite = 1 + + # if self.waitCo(): + # CCAR : il ne faut pas essayer de creer un concept + # il faut simplement en chercher un existant ce qui a du etre fait par self.object.evalValeur(valeur) + # try: + # valeurretour=Accas.CO(valeur) + # except: + # valeurretour=None + # validite=0 + # on est dans le cas ou on a evalue et ou on n'aurait pas du + if self.object.waitTxm(): + if type(valeurretour) != bytes: + valeurretour = str(valeur) + validite = 1 + return valeurretour, validite + + def isCO(self, valeur=None): + """ + Indique si valeur est un concept produit de la macro + Cette methode n'a de sens que pour un MCSIMP d'une MACRO + Si valeur vaut None on teste la valeur du mot cle + """ + # Pour savoir si un concept est un nouveau concept de macro + # on regarde s'il est present dans l'attribut sdprods de l'etape + # ou si son nom de classe est CO. + # Il faut faire les 2 tests car une macro non valide peut etre + # dans un etat pas tres catholique avec des CO pas encore types + # et donc pas dans sdprods (resultat d'une exception dans typeSDProd) + if not valeur: + valeur = self.object.valeur + if valeur in self.object.etape.sdprods: + return 1 + # if type(valeur) is not types.InstanceType:return 0 + if type(valeur) is not object: + return 0 + if valeur.__class__.__name__ == "CO": + return 1 + return 0 + + def isParam(self, valeur): + for param in self.jdc.params: + if repr(param) == valeur: + return 1 + return 0 + + def traiteReel(self, valeur): + """ + Cette fonction a pour but de rajouter le '.' en fin de chaine pour un reel + ou de detecter si on fait reference a un concept produit + 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 + diff --git a/InterfaceGUI/Common/traiteSaisie.py b/InterfaceGUI/Common/traiteSaisie.py new file mode 100644 index 00000000..c2a93a1a --- /dev/null +++ b/InterfaceGUI/Common/traiteSaisie.py @@ -0,0 +1,181 @@ +# -*- 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 Accas.extensions.eficas_translation 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.afficheMessage(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.afficheMessage("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.afficheMessage(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.afficheMessage(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.afficheMessage(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() diff --git a/InterfaceGUI/QT5/browser.py b/InterfaceGUI/QT5/browser.py index b9e3ed6a..265d178f 100644 --- a/InterfaceGUI/QT5/browser.py +++ b/InterfaceGUI/QT5/browser.py @@ -159,6 +159,11 @@ class JDCTree(QTreeWidget, GereRegles): self.inhibeExpand = True self.itemCourant = item + # on a clique sur le jdc + if isinstance(item, compojdc.Node) : + item.affichePanneau() + return + itemParent = item.treeParent itemAvant = item @@ -166,10 +171,8 @@ class JDCTree(QTreeWidget, GereRegles): #print (isinstance(itemParent, compojdc.Node)) # on a clique sur une etape if isinstance(itemParent, compojdc.Node) : - if not (item.fenetre): - item.affichePanneau() - elif item.fenetre != self.editor.fenetreCentraleAffichee: - item.affichePanneau() + if not (item.fenetre): item.affichePanneau() + elif item.fenetre != self.editor.fenetreCentraleAffichee: item.affichePanneau() return while not (hasattr(itemParent, "getPanel")): if itemParent.plie == True: itemParent.setDeplie() diff --git a/InterfaceGUI/QT5/compobloc.py b/InterfaceGUI/QT5/compobloc.py index f58ebcfc..dadaabbb 100644 --- a/InterfaceGUI/QT5/compobloc.py +++ b/InterfaceGUI/QT5/compobloc.py @@ -18,7 +18,7 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.QT5 import compofact from InterfaceGUI.QT5 import browser diff --git a/InterfaceGUI/QT5/compocomm.py b/InterfaceGUI/QT5/compocomm.py index 5101011b..1d5b29d7 100644 --- a/InterfaceGUI/QT5/compocomm.py +++ b/InterfaceGUI/QT5/compocomm.py @@ -17,7 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.QT5 import browser from InterfaceGUI.QT5 import typeNode from Accas.extensions.eficas_translation import tr diff --git a/InterfaceGUI/QT5/compocommandecomm.py b/InterfaceGUI/QT5/compocommandecomm.py index a899911d..31462d13 100644 --- a/InterfaceGUI/QT5/compocommandecomm.py +++ b/InterfaceGUI/QT5/compocommandecomm.py @@ -20,7 +20,7 @@ import traceback -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from Accas.extensions.eficas_exception import EficasException from InterfaceGUI.QT5 import compocomm diff --git a/InterfaceGUI/QT5/compofact.py b/InterfaceGUI/QT5/compofact.py index 78fc9ba9..96a924d7 100644 --- a/InterfaceGUI/QT5/compofact.py +++ b/InterfaceGUI/QT5/compofact.py @@ -22,7 +22,7 @@ from InterfaceGUI.QT5 import browser from InterfaceGUI.QT5 import typeNode from Accas.extensions.eficas_translation import tr -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem import traceback diff --git a/InterfaceGUI/QT5/compojdc.py b/InterfaceGUI/QT5/compojdc.py index 918e28aa..05e6cc55 100644 --- a/InterfaceGUI/QT5/compojdc.py +++ b/InterfaceGUI/QT5/compojdc.py @@ -18,7 +18,7 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.QT5 import browser from InterfaceGUI.QT5 import typeNode from Accas.extensions.eficas_translation import tr diff --git a/InterfaceGUI/QT5/compomacro.py b/InterfaceGUI/QT5/compomacro.py index 465eb001..ebbcfe6e 100644 --- a/InterfaceGUI/QT5/compomacro.py +++ b/InterfaceGUI/QT5/compomacro.py @@ -25,7 +25,7 @@ import types import traceback # Modules Eficas -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5 import compooper from InterfaceGUI.QT5 import browser diff --git a/InterfaceGUI/QT5/compomclist.py b/InterfaceGUI/QT5/compomclist.py index 08c70279..d0100372 100644 --- a/InterfaceGUI/QT5/compomclist.py +++ b/InterfaceGUI/QT5/compomclist.py @@ -27,7 +27,7 @@ from InterfaceGUI.QT5 import browser from InterfaceGUI.QT5 import typeNode from Accas.extensions.eficas_translation import tr -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from Accas.processing.P_OBJECT import ErrorObj diff --git a/InterfaceGUI/QT5/compooper.py b/InterfaceGUI/QT5/compooper.py index 9d45e6ee..1e907268 100644 --- a/InterfaceGUI/QT5/compooper.py +++ b/InterfaceGUI/QT5/compooper.py @@ -23,7 +23,7 @@ import tempfile from Accas.extensions.eficas_translation import tr from Accas.extensions.eficas_exception import EficasException -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.QT5 import browser from InterfaceGUI.QT5 import typeNode diff --git a/InterfaceGUI/QT5/compoparam.py b/InterfaceGUI/QT5/compoparam.py index dc7d1339..592c714c 100644 --- a/InterfaceGUI/QT5/compoparam.py +++ b/InterfaceGUI/QT5/compoparam.py @@ -27,16 +27,16 @@ import types from Accas.extensions.eficas_translation import tr # import modules EFICAS -from InterfaceGUI.common import objecttreeitem -from InterfaceGUI.QT5 import browser +from InterfaceGUI.Common.param_treeItem_commun import PARAMTreeItemCommun from InterfaceGUI.QT5 import typeNode +from InterfaceGUI.QT5 import browser +from Accas.extensions.parametre import PARAMETRE class Node(browser.JDCNode, typeNode.PopUpMenuNodePartiel): def getPanel(self): """ """ from InterfaceGUI.QT5.monWidgetParam import MonWidgetParam - return MonWidgetParam(self, self.editor, self.item.object) def createPopUpMenu(self): @@ -47,107 +47,8 @@ class Node(browser.JDCNode, typeNode.PopUpMenuNodePartiel): return None -class PARAMTreeItem(objecttreeitem.ObjectTreeItem): - """ - Classe servant a definir l'item porte par le noeud de l'arbre d'EFICAS - qui represente le PARAMETRE - """ - +class PARAMTreeItem(PARAMTreeItemCommun): 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 Accas.extensions.parametre - treeitem = PARAMTreeItem -objet = Accas.extensions.parametre.PARAMETRE +objet = PARAMETRE diff --git a/InterfaceGUI/QT5/compoproc.py b/InterfaceGUI/QT5/compoproc.py index 0242b7b3..2954c4b3 100644 --- a/InterfaceGUI/QT5/compoproc.py +++ b/InterfaceGUI/QT5/compoproc.py @@ -18,7 +18,7 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.QT5 import compooper from InterfaceGUI.QT5 import browser from InterfaceGUI.QT5 import typeNode diff --git a/InterfaceGUI/QT5/composimp.py b/InterfaceGUI/QT5/composimp.py index 86e006e6..8a40d3d8 100644 --- a/InterfaceGUI/QT5/composimp.py +++ b/InterfaceGUI/QT5/composimp.py @@ -22,15 +22,13 @@ import types, os from copy import copy, deepcopy import traceback -from InterfaceGUI.QT5 import typeNode # Modules Eficas -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem +from InterfaceGUI.Common.simp_treeItem_commun import SIMPTreeItemCommun from InterfaceGUI.QT5 import browser +from InterfaceGUI.QT5 import typeNode from Accas import SalomeEntry -from Accas import ASSD -from Accas import UserASSD -from Accas import UserASSDMultiple class NodeCommun: @@ -257,602 +255,6 @@ class Node(NodeCommun, browser.JDCNode, typeNode.PopUpMenuNodeMinimal): typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self) -class SIMPTreeItemCommun(objecttreeitem.AtomicObjectTreeItem): - - def init(self): - self.expandable = 0 - - # ----------------------------------------------- - # - # Methodes liees aux informations sur le Panel - # ou au mot-clef simple - # - # ----------------------------------------------- - # isList - # hasInto - # getMinMax - # getMultiplicite - # getIntervalle - # getListeValeurs - # getListePossible - - def isList(self): - """ - Cette methode indique si le mot cle simple attend une liste (valeur de retour 1) - ou s'il n'en attend pas (valeur de retour 0) - - Deux cas principaux peuvent se presenter : avec validateurs ou bien sans. - Dans le cas sans validateur, l'information est donnee par l'attribut max - de la definition du mot cle. - Dans le cas avec validateur, il faut combiner l'information precedente avec - celle issue de l'appel de la methode isList sur le validateur.On utilisera - l'operateur ET pour effectuer cette combinaison (AndVal). - """ - is_a_list = 0 - min, max = self.getMinMax() - assert min <= max - if max > 1: - is_a_list = 1 - # Dans le cas avec validateurs, pour que le mot cle soit considere - # comme acceptant une liste, il faut que max soit superieur a 1 - # ET que la methode isList du validateur retourne 1. Dans les autres cas - # on retournera 0 (n'attend pas de liste) - if self.definition.validators: - is_a_list = self.definition.validators.isList() * is_a_list - return is_a_list - - def isListSansOrdreNiDoublon(self): - if self.definition.homo == "SansOrdreNiDoublon": - return 1 - return 0 - - def hasInto(self): - """ - Cette methode indique si le mot cle simple propose un choix (valeur de retour 1) - ou s'il n'en propose pas (valeur de retour 0) - - Deux cas principaux peuvent se presenter : avec validateurs ou bien sans. - Dans le cas sans validateur, l'information est donnee par l'attribut into - de la definition du mot cle. - Dans le cas avec validateurs, pour que le mot cle soit considere - comme proposant un choix, il faut que into soit present OU - que la methode hasInto du validateur retourne 1. Dans les autres cas - on retournera 0 (ne propose pas de choix) - """ - has_an_into = 0 - if self.definition.into: - has_an_into = 1 - elif self.definition.validators: - has_an_into = self.definition.validators.hasInto() - return has_an_into - - def hasIntoSug(self): - if self.definition.intoSug: - return 1 - return 0 - - def getMinMax(self): - """Retourne les valeurs min et max de la definition de object""" - return self.object.getMinMax() - - def getMultiplicite(self): - """A preciser. - Retourne la multiplicite des valeurs affectees a l'objet - represente par l'item. Pour le moment retourne invariablement 1. - """ - return 1 - - def getIntervalle(self): - """ - Retourne le domaine de valeur attendu par l'objet represente - par l'item. - """ - return self.object.getintervalle() - - def getListeValeurs(self): - """Retourne la liste des valeurs de object""" - valeurs = self.object.getListeValeurs() - try: - if "R" in self.object.definition.type: - clef = self.object.getNomConcept() - if clef in self.appliEficas.dict_reels: - if type(valeurs) == tuple: - valeurs_reelles = [] - for val in valeurs: - if val in self.appliEficas.dict_reels[clef]: - valeurs_reelles.append( - self.appliEficas.dict_reels[clef][val] - ) - else: - valeurs_reelles.append(val) - else: - if valeurs in self.appliEficas.dict_reels[clef]: - valeurs_reelles = self.appliEficas.dict_reels[clef][valeurs] - valeurs = valeurs_reelles - except: - pass - return valeurs - - def getListePossible(self, listeActuelle=[]): - if hasattr(self.definition.validators, "into"): - valeurspossibles = self.definition.validators.into - else: - valeurspossibles = self.get_definition().into - - if listeActuelle == []: - return valeurspossibles - - # On ne garde que les items valides - listevalideitem = [] - if type(valeurspossibles) in (list, tuple): - pass - else: - valeurspossibles = (valeurspossibles,) - for item in valeurspossibles: - encorevalide = self.valideItem(item) - if encorevalide: - listevalideitem.append(item) - - # on ne garde que les choix possibles qui passent le test de valideListePartielle - listevalideliste = [] - for item in listevalideitem: - encorevalide = self.valideListePartielle(item, listeActuelle) - if encorevalide: - listevalideliste.append(item) - # print listevalideliste - return listevalideliste - - def getListePossibleAvecSug(self, listeActuelle=[]): - if hasattr(self.definition, "intoSug"): - valeurspossibles = self.definition.intoSug - else: - return listeActuelle - - if listeActuelle == []: - return valeurspossibles - valeurspossibles = valeurspossibles + listeActuelle - - # On ne garde que les items valides - listevalideitem = [] - if type(valeurspossibles) in (list, tuple): - pass - else: - valeurspossibles = (valeurspossibles,) - for item in valeurspossibles: - encorevalide = self.valideItem(item) - if encorevalide: - listevalideitem.append(item) - - # on ne garde que les choix possibles qui passent le test de valideListePartielle - listevalideliste = [] - for item in listevalideitem: - encorevalide = self.valideListePartielle(item, listeActuelle) - if encorevalide: - listevalideliste.append(item) - return listevalideliste - - def getListeParamPossible(self): - liste_param = [] - l1, l2 = self.jdc.getParametresFonctionsAvantEtape(self.getEtape()) - for param in self.object.jdc.params: - if param.nom not in l1: - continue - encorevalide = self.valideItem(param.valeur) - if encorevalide: - type_param = param.valeur.__class__.__name__ - for typ in self.definition.type: - if typ == "R": - liste_param.append(param) - if typ == "I" and type_param == "int": - liste_param.append(param) - if typ == "TXM" and type_param == "str": - liste_param.append(repr(param)) - if ("grma" in repr(typ)) and type_param == "str": - liste_param.append(param.nom) - return liste_param - - # -------------------------------------------------- - # - # Methodes liees a la validite des valeurs saisies - # - # --------------------------------------------------- - # valideItem - # valideListePartielle - # valideListeComplete - # infoErreurItem - # infoErreurListe - # isInIntervalle - # isValid - - def valideItem(self, item): - """ - La validation est realisee directement par l'objet - """ - return self.object.valideItem(item) - - def valideListePartielle(self, item, listecourante): - # On protege la liste en entree en la copiant - valeur = list(listecourante) - if item: - valeur.append(item) - return self.object.validValeurPartielle(valeur) - - def valideListeComplete(self, valeur): - return self.object.validValeur(valeur) - - def infoErreurItem(self): - commentaire = "" - if self.definition.validators: - commentaire = self.definition.validators.infoErreurItem() - return commentaire - - def aide(self): - commentaire = "" - if self.definition.validators: - commentaire = self.definition.validators.aide() - return commentaire - - def infoErreurListe(self): - commentaire = "" - if self.definition.validators: - commentaire = self.definition.validators.infoErreurListe() - return commentaire - - def isInIntervalle(self, valeur): - """ - Retourne 1 si la valeur est dans l'intervalle permis par - l'objet represente par l'item. - """ - return self.valideItem(valeur) - - def isValid(self): - valide = self.object.isValid() - return valide - - # -------------------------------------------------- - # - # Autres ... - # - # --------------------------------------------------- - # getIconName - # getText - # setValeurCo - # getSdAvantDuBonType - - def getIconName(self): - if self.appliEficas.maConfiguration.differencieSiDefaut and self.isValid(): - if self.object.definition.defaut != None: - if self.object.valeur == self.object.definition.defaut: - return "ast-green-dark-ball" - if self.object.definition.max > 1 and list(self.object.valeur) == list( - self.object.definition.defaut - ): - return "ast-green-dark-ball" - return "ast-green-ball" - elif self.isValid(): - return "ast-green-ball" - elif self.object.isOblig(): - return "ast-red-ball" - else: - return "ast-yel-ball" - - def getText(self): - """ - Classe SIMPTreeItem - Retourne le texte a afficher dans l'arbre representant la valeur de l'objet - pointe par self - """ - if ( - self.waitUserAssdMultiple() - or self.object.waitUserAssd() - or self.object.waitAssd() - ): - return self.object.valeur - # if self.object.valeur != None : return self.object.valeur.nom - # else : return "" - text = self.object.getText() - if text == None: - text = "" - return text - - def setValeurCo(self, nomCo): - """ - Affecte au MCS pointe par self l'objet de type CO et de nom nom_co - """ - ret = self.object.setValeurCo(nomCo) - # print "setValeurCo",ret - return ret - - def getSdAvantDuBonType(self): - """ - Retourne la liste des noms des SD presentes avant l'etape qui contient - le MCS pointe par self et du type requis par ce MCS - """ - # A changer pour tenir compte des UserASSDMultiple - # ici on passe par parent pour avoir le bon type - # if self.waitUserAssdMultiple() : - # l=self.object.parent.getSdCreeParObjetAvecFiltre(self.object) - # return l - if self.waitUserAssdMultiple(): - l = self.object.getUserAssdPossible() - return l - a = self.object.etape.parent.getSdAvantDuBonType( - self.object.etape, self.object.definition.type - ) - if self.waitUserAssd(): - l = self.jdc.getSdCreeParObjet(self.object.definition.type) - else: - l = [] - return a + l - - def getSdAvantDuBonTypePourTypeDeBase(self): - a = self.object.jdc.getSdAvantDuBonTypePourTypeDe_Base( - self.object.etape, "LASSD" - ) - return a - - def deleteValeurCo(self, valeur=None): - """ - Supprime la valeur du mot cle (de type CO) - il faut propager la destruction aux autres etapes - """ - if not valeur: - valeur = self.object.valeur - # XXX faut il vraiment appeler delSdprod ??? - # self.object.etape.parent.delSdprod(valeur) - self.object.etape.parent.deleteConcept(valeur) - - # ----------------------------------------------- - # - # Methodes liees au type de l objet attendu - # - # ----------------------------------------------- - # waitCo - # waitGeom - # waitComplex - # waitReel - # waitAssd - # getType - - def waitCo(self): - """ - Methode booleenne qui retourne 1 si l'objet pointe par self - attend un objet de type ASSD qui n'existe pas encore (type CO()), - 0 sinon - """ - return self.object.waitCo() - - def waitFichier(self): - maDefinition = self.object.definition - try: - if ("Repertoire" in maDefinition.type[0]) or ( - "Fichier" in maDefinition.type[0] - ): - return 1 - except: - return 0 - - def waitGeom(self): - """ - Methode booleenne qui retourne 1 si l'objet pointe par self - attend un objet GEOM, 0 sinon - """ - return self.object.waitGeom() - - def waitTxm(self): - return self.object.waitTxm() - - def waitComplex(self): - """Methode booleenne qui retourne 1 si l'objet pointe par self - attend un complexe, 0 sinon""" - if "C" in self.object.definition.type: - return 1 - else: - return 0 - - def waitReel(self): - """Methode booleenne qui retourne 1 si l'objet pointe par self - attend un reel, 0 sinon""" - if "R" in self.object.definition.type: - return 1 - else: - return 0 - - def waitTuple(self): - return self.object.waitTuple() - - def waitDate(self): - """Methode booleenne qui retourne 1 si l'objet pointe par self - attend un reel, 0 sinon""" - if "DateHHMMAAAA" in self.object.definition.type: - return 1 - else: - return 0 - - def waitHeure(self): - """Methode booleenne qui retourne 1 si l'objet pointe par self - attend un reel, 0 sinon""" - if "HeureHHMMSS" in self.object.definition.type: - return 1 - else: - return 0 - - def waitTuple(self): - """Methode booleenne qui retourne 1 si l'objet pointe par self - attend un Tuple, 0 sinon""" - for ss_type in self.object.definition.type: - if repr(ss_type).find("Tuple") != -1: - return 1 - return 0 - - def waitMatrice(self): - """Methode booleenne qui retourne 1 si l'objet pointe par self - attend un Tuple, 0 sinon""" - # il faut trouver autre chose que ce find!!! - for ss_type in self.object.definition.type: - # if repr(ss_type).find('Matrice') != -1 : - if hasattr(ss_type, "typElt"): - return 1 - return 0 - - def waitAssd(self): - """Methode booleenne qui retourne 1 si l'objet pointe par self - attend un objet de type ASSD ou derive, 0 sinon""" - return self.object.waitAssd() - - def waitAssdOrTypeBase(self): - boo = 0 - if len(self.object.definition.type) > 1: - if self.waitReel(): - boo = 1 - if "I" in self.object.definition.type: - boo = 1 - return boo - - def waitSalome(self): - monType = self.object.definition.type[0] - if "grma" in repr(monType): - return True - if "grno" in repr(monType): - return True - try: - if issubclass(monType, SalomeEntry): - return True - except: - pass - return False - - def getType(self): - """ - Retourne le type de valeur attendu par l'objet represente par l'item. - """ - return self.object.getType() - - # ----------------------------------------------------- - # - # Methodes liees a l evaluation de la valeur saisie - # - # ----------------------------------------------------- - # evalValeur - # evalValeurItem - # isCO - # traiteReel - - def evalValeur(self, valeur): - """Lance l'interpretation de 'valeur' (chaine de caracteres) comme valeur de self : - - retourne l'objet associe si on a pu interpreter (entier, reel, ASSD,...) - - retourne 'valeur' (chaine de caracteres) sinon - """ - newvaleur = self.evalVal(valeur) - return newvaleur, 1 - - def evalValeurItem(self, valeur): - """Lance l'interpretation de 'valeur' qui doit ne pas etre un tuple - - va retourner la valeur de retour et la validite - selon le type de l objet attendu - - traite les reels et les parametres - """ - # print "evalValeurItem",valeur - if valeur == None or valeur == "": - return None, 0 - validite = 1 - if self.waitReel(): - valeurinter = self.traiteReel(valeur) - if valeurinter != None: - valeurretour, validite = self.object.evalValeur(valeurinter) - else: - valeurretour, validite = self.object.evalValeur(valeur) - elif self.waitGeom(): - valeurretour, validite = valeur, 1 - else: - valeurretour, validite = self.object.evalValeur(valeur) - - if validite == 0: - if (type(valeur) == bytes or type(valeur) == str) and self.object.waitTxm(): - essai_valeur = "'" + valeur + "'" - valeurretour, validite = self.object.evalValeur(essai_valeur) - - if hasattr(valeurretour, "__class__"): - # if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'): - if valeurretour.__class__.__name__ in ("PARAMETRE",): - validite = 1 - - # if self.waitCo(): - # CCAR : il ne faut pas essayer de creer un concept - # il faut simplement en chercher un existant ce qui a du etre fait par self.object.evalValeur(valeur) - # try: - # valeurretour=Accas.CO(valeur) - # except: - # valeurretour=None - # validite=0 - # on est dans le cas ou on a evalue et ou on n'aurait pas du - if self.object.waitTxm(): - if type(valeurretour) != bytes: - valeurretour = str(valeur) - validite = 1 - return valeurretour, validite - - def isCO(self, valeur=None): - """ - Indique si valeur est un concept produit de la macro - Cette methode n'a de sens que pour un MCSIMP d'une MACRO - Si valeur vaut None on teste la valeur du mot cle - """ - # Pour savoir si un concept est un nouveau concept de macro - # on regarde s'il est present dans l'attribut sdprods de l'etape - # ou si son nom de classe est CO. - # Il faut faire les 2 tests car une macro non valide peut etre - # dans un etat pas tres catholique avec des CO pas encore types - # et donc pas dans sdprods (resultat d'une exception dans typeSDProd) - if not valeur: - valeur = self.object.valeur - if valeur in self.object.etape.sdprods: - return 1 - # if type(valeur) is not types.InstanceType:return 0 - if type(valeur) is not object: - return 0 - if valeur.__class__.__name__ == "CO": - return 1 - return 0 - - def isParam(self, valeur): - for param in self.jdc.params: - if repr(param) == valeur: - return 1 - return 0 - - def traiteReel(self, valeur): - """ - Cette fonction a pour but de rajouter le '.' en fin de chaine pour un reel - ou de detecter si on fait reference a un concept produit - 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 - - class SIMPTreeItem(SIMPTreeItemCommun): itemNode = Node diff --git a/InterfaceGUI/QT5/feuille.py b/InterfaceGUI/QT5/feuille.py index 91a1a67d..e78cbdbc 100644 --- a/InterfaceGUI/QT5/feuille.py +++ b/InterfaceGUI/QT5/feuille.py @@ -30,7 +30,7 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.gereIcones import ContientIcones from InterfaceGUI.QT5.gereIcones import FacultatifOuOptionnel -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.traiteSaisie import SaisieValeur nomMax = 230 diff --git a/InterfaceGUI/QT5/monFonctionPanel.py b/InterfaceGUI/QT5/monFonctionPanel.py index d6afc840..8413018e 100644 --- a/InterfaceGUI/QT5/monFonctionPanel.py +++ b/InterfaceGUI/QT5/monFonctionPanel.py @@ -24,7 +24,7 @@ from PyQt5.QtCore import Qt # Modules Eficas -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.traiteSaisie import SaisieValeur from InterfaceGUI.QT5.monPlusieursBasePanel import MonPlusieursBasePanel from Accas.extensions.eficas_translation import tr diff --git a/InterfaceGUI/QT5/monWidgetCB.py b/InterfaceGUI/QT5/monWidgetCB.py index 756fec16..7e20243c 100644 --- a/InterfaceGUI/QT5/monWidgetCB.py +++ b/InterfaceGUI/QT5/monWidgetCB.py @@ -26,8 +26,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetCB import Ui_WidgetCB -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.traiteSaisie import SaisieValeur from PyQt5.QtWidgets import QComboBox, QCompleter from PyQt5.QtCore import Qt, QEvent diff --git a/InterfaceGUI/QT5/monWidgetCBIntoSug.py b/InterfaceGUI/QT5/monWidgetCBIntoSug.py index 1979ac4a..92a03d67 100644 --- a/InterfaceGUI/QT5/monWidgetCBIntoSug.py +++ b/InterfaceGUI/QT5/monWidgetCBIntoSug.py @@ -26,8 +26,8 @@ import types, os from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.traiteSaisie import SaisieValeur from UiQT5.desWidgetCBIntoSug import Ui_WidgetCBIntoSug from PyQt5.QtWidgets import QComboBox, QCompleter diff --git a/InterfaceGUI/QT5/monWidgetCBSD.py b/InterfaceGUI/QT5/monWidgetCBSD.py index cf6f6f21..08a5e1aa 100644 --- a/InterfaceGUI/QT5/monWidgetCBSD.py +++ b/InterfaceGUI/QT5/monWidgetCBSD.py @@ -26,8 +26,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetCB import Ui_WidgetCB -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.traiteSaisie import SaisieValeur from PyQt5.QtWidgets import QComboBox, QCompleter diff --git a/InterfaceGUI/QT5/monWidgetCommande.py b/InterfaceGUI/QT5/monWidgetCommande.py index 1248a2e3..52ad151f 100644 --- a/InterfaceGUI/QT5/monWidgetCommande.py +++ b/InterfaceGUI/QT5/monWidgetCommande.py @@ -239,7 +239,7 @@ class MonWidgetCommande(Ui_WidgetCommande, Groupe): # Notation scientifique if test: - from InterfaceGUI.common.politiquesValidation import Validation + from InterfaceGUI.Common.politiquesValidation import Validation validation = Validation(self.node, self.editor) validation.ajoutDsDictReelEtape() diff --git a/InterfaceGUI/QT5/monWidgetCreeParam.py b/InterfaceGUI/QT5/monWidgetCreeParam.py index 3aa96c07..e386cd06 100644 --- a/InterfaceGUI/QT5/monWidgetCreeParam.py +++ b/InterfaceGUI/QT5/monWidgetCreeParam.py @@ -95,7 +95,7 @@ class MonWidgetCreeParam(Ui_desWidgetCreeParam, QDialog): valString = str(self.lineEditVal.text()) self.val = "" contexte = {} - exec("from InterfaceGUI.QT5.ath import *", contexte) + exec("from math import *", contexte) jdc = self.editor.jdc if jdc == None: self.editor.afficheMessage( diff --git a/InterfaceGUI/QT5/monWidgetPlusieursASSDIntoOrdonne.py b/InterfaceGUI/QT5/monWidgetPlusieursASSDIntoOrdonne.py index 78f3c6ed..c33bb9fd 100644 --- a/InterfaceGUI/QT5/monWidgetPlusieursASSDIntoOrdonne.py +++ b/InterfaceGUI/QT5/monWidgetPlusieursASSDIntoOrdonne.py @@ -21,7 +21,7 @@ # Modules Eficas from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne -from InterfaceGUI.common.politiquesValidation import PolitiquePlusieurs +from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs from PyQt5.QtWidgets import QScrollBar diff --git a/InterfaceGUI/QT5/monWidgetPlusieursBase.py b/InterfaceGUI/QT5/monWidgetPlusieursBase.py index cf9199cc..057d420f 100644 --- a/InterfaceGUI/QT5/monWidgetPlusieursBase.py +++ b/InterfaceGUI/QT5/monWidgetPlusieursBase.py @@ -29,8 +29,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetPlusieursBase import Ui_WidgetPlusieursBase -from InterfaceGUI.common.politiquesValidation import PolitiquePlusieurs -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs +from InterfaceGUI.Common.traiteSaisie import SaisieValeur from InterfaceGUI.QT5.gereListe import GereListe from InterfaceGUI.QT5.gereListe import GerePlie from InterfaceGUI.QT5.gereListe import LECustom diff --git a/InterfaceGUI/QT5/monWidgetPlusieursInto.py b/InterfaceGUI/QT5/monWidgetPlusieursInto.py index 73b7d7c1..f2737eec 100644 --- a/InterfaceGUI/QT5/monWidgetPlusieursInto.py +++ b/InterfaceGUI/QT5/monWidgetPlusieursInto.py @@ -28,8 +28,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetPlusieursInto import Ui_WidgetPlusieursInto -from InterfaceGUI.common.politiquesValidation import PolitiquePlusieurs -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs +from InterfaceGUI.Common.traiteSaisie import SaisieValeur from InterfaceGUI.QT5.gereListe import GerePlie from InterfaceGUI.QT5.gereListe import GereListe diff --git a/InterfaceGUI/QT5/monWidgetPlusieursIntoOrdonne.py b/InterfaceGUI/QT5/monWidgetPlusieursIntoOrdonne.py index 90940295..829e2a68 100644 --- a/InterfaceGUI/QT5/monWidgetPlusieursIntoOrdonne.py +++ b/InterfaceGUI/QT5/monWidgetPlusieursIntoOrdonne.py @@ -23,8 +23,8 @@ import types, os # Modules Eficas from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetPlusieursIntoOrdonne import Ui_WidgetPlusieursIntoOrdonne -from InterfaceGUI.common.politiquesValidation import PolitiquePlusieurs -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs +from InterfaceGUI.Common.traiteSaisie import SaisieValeur from InterfaceGUI.QT5.gereListe import GereListe from InterfaceGUI.QT5.gereListe import GerePlie from InterfaceGUI.QT5.gereListe import LECustom diff --git a/InterfaceGUI/QT5/monWidgetPlusieursPlie.py b/InterfaceGUI/QT5/monWidgetPlusieursPlie.py index 79077377..07b2eb88 100644 --- a/InterfaceGUI/QT5/monWidgetPlusieursPlie.py +++ b/InterfaceGUI/QT5/monWidgetPlusieursPlie.py @@ -28,8 +28,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetPlusieursPlie import Ui_WidgetPlusieursPlie -from InterfaceGUI.common.politiquesValidation import PolitiquePlusieurs -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs +from InterfaceGUI.Common.traiteSaisie import SaisieValeur pattern_blanc = re.compile(r"^\s*$") diff --git a/InterfaceGUI/QT5/monWidgetPlusieursTuple.py b/InterfaceGUI/QT5/monWidgetPlusieursTuple.py index dadd1683..5c4384b0 100644 --- a/InterfaceGUI/QT5/monWidgetPlusieursTuple.py +++ b/InterfaceGUI/QT5/monWidgetPlusieursTuple.py @@ -26,8 +26,8 @@ from PyQt5.QtCore import QSize, Qt, QTimer from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille -from InterfaceGUI.common.politiquesValidation import PolitiquePlusieurs -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs +from InterfaceGUI.Common.traiteSaisie import SaisieValeur from InterfaceGUI.QT5.gereListe import GereListe from InterfaceGUI.QT5.gereListe import LECustom from UiQT5.Tuple2 import Ui_Tuple2 diff --git a/InterfaceGUI/QT5/monWidgetRadioButton.py b/InterfaceGUI/QT5/monWidgetRadioButton.py index 8cdbba20..f57845d6 100644 --- a/InterfaceGUI/QT5/monWidgetRadioButton.py +++ b/InterfaceGUI/QT5/monWidgetRadioButton.py @@ -30,8 +30,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetRadioButton import Ui_WidgetRadioButton -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.traiteSaisie import SaisieValeur class MonWidgetRadioButtonCommun(Feuille): diff --git a/InterfaceGUI/QT5/monWidgetSDCOInto.py b/InterfaceGUI/QT5/monWidgetSDCOInto.py index 399bdeff..3fa7368a 100644 --- a/InterfaceGUI/QT5/monWidgetSDCOInto.py +++ b/InterfaceGUI/QT5/monWidgetSDCOInto.py @@ -25,8 +25,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetSDCOInto import Ui_WidgetSDCOInto -from InterfaceGUI.common.traiteSaisie import SaisieSDCO -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.traiteSaisie import SaisieSDCO +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique class MonWidgetSDCOInto(Ui_WidgetSDCOInto, Feuille, SaisieSDCO): diff --git a/InterfaceGUI/QT5/monWidgetSimpBase.py b/InterfaceGUI/QT5/monWidgetSimpBase.py index 33a067d7..51442f63 100644 --- a/InterfaceGUI/QT5/monWidgetSimpBase.py +++ b/InterfaceGUI/QT5/monWidgetSimpBase.py @@ -25,8 +25,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetSimpBase import Ui_WidgetSimpBase -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.traiteSaisie import SaisieValeur class MonWidgetSimpBase(Ui_WidgetSimpBase, Feuille): diff --git a/InterfaceGUI/QT5/monWidgetSimpBool.py b/InterfaceGUI/QT5/monWidgetSimpBool.py index 07727e7d..39fd2bd2 100644 --- a/InterfaceGUI/QT5/monWidgetSimpBool.py +++ b/InterfaceGUI/QT5/monWidgetSimpBool.py @@ -24,8 +24,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetSimpBool import Ui_WidgetSimpBool -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.traiteSaisie import SaisieValeur class MonWidgetSimpBool(Ui_WidgetSimpBool, Feuille): diff --git a/InterfaceGUI/QT5/monWidgetSimpComplexe.py b/InterfaceGUI/QT5/monWidgetSimpComplexe.py index 9bbdf199..ba16f9d7 100644 --- a/InterfaceGUI/QT5/monWidgetSimpComplexe.py +++ b/InterfaceGUI/QT5/monWidgetSimpComplexe.py @@ -29,8 +29,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetSimpComplexe import Ui_WidgetSimpComplexe -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.traiteSaisie import SaisieValeur class MonWidgetSimpComplexe(Ui_WidgetSimpComplexe, Feuille): diff --git a/InterfaceGUI/QT5/monWidgetSimpDate.py b/InterfaceGUI/QT5/monWidgetSimpDate.py index eaf5eb1d..a7d205ea 100644 --- a/InterfaceGUI/QT5/monWidgetSimpDate.py +++ b/InterfaceGUI/QT5/monWidgetSimpDate.py @@ -24,7 +24,7 @@ import types,os # Modules Eficas from PyQt5.QtCore import QDate from UiQT5.desWidgetDate import Ui_WidgetDate -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique from InterfaceGUI.QT5.feuille import Feuille diff --git a/InterfaceGUI/QT5/monWidgetSimpSalome.py b/InterfaceGUI/QT5/monWidgetSimpSalome.py index 6009cac3..024dfe57 100644 --- a/InterfaceGUI/QT5/monWidgetSimpSalome.py +++ b/InterfaceGUI/QT5/monWidgetSimpSalome.py @@ -25,8 +25,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetSimpSalome import Ui_WidgetSimpSalome -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.traiteSaisie import SaisieValeur class MonWidgetSimpSalome(Ui_WidgetSimpSalome, Feuille): diff --git a/InterfaceGUI/QT5/monWidgetSimpTuple.py b/InterfaceGUI/QT5/monWidgetSimpTuple.py index d764fb12..938ffc01 100644 --- a/InterfaceGUI/QT5/monWidgetSimpTuple.py +++ b/InterfaceGUI/QT5/monWidgetSimpTuple.py @@ -24,8 +24,8 @@ from PyQt5.QtCore import Qt from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique -from InterfaceGUI.common.traiteSaisie import SaisieValeur +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.traiteSaisie import SaisieValeur class MonWidgetSimpTuple(Feuille): diff --git a/InterfaceGUI/QT5/monWidgetUniqueSDCO.py b/InterfaceGUI/QT5/monWidgetUniqueSDCO.py index 3ef7689c..ae61327f 100644 --- a/InterfaceGUI/QT5/monWidgetUniqueSDCO.py +++ b/InterfaceGUI/QT5/monWidgetUniqueSDCO.py @@ -25,8 +25,8 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetUniqueSDCO import Ui_WidgetUniqueSDCO -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique -from InterfaceGUI.common.traiteSaisie import SaisieSDCO +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.traiteSaisie import SaisieSDCO class MonWidgetUniqueSDCO(Ui_WidgetUniqueSDCO, Feuille, SaisieSDCO): diff --git a/InterfaceGUI/QT5/monWidgetVide.py b/InterfaceGUI/QT5/monWidgetVide.py index 5467a453..7e594130 100644 --- a/InterfaceGUI/QT5/monWidgetVide.py +++ b/InterfaceGUI/QT5/monWidgetVide.py @@ -23,7 +23,7 @@ from Accas.extensions.eficas_translation import tr from InterfaceGUI.QT5.feuille import Feuille from UiQT5.desWidgetVide import Ui_WidgetVide -from InterfaceGUI.common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique class MonWidgetVide(Ui_WidgetVide, Feuille): diff --git a/InterfaceGUI/QT5/qt_editor.py b/InterfaceGUI/QT5/qt_editor.py index 371da4f4..413f3257 100755 --- a/InterfaceGUI/QT5/qt_editor.py +++ b/InterfaceGUI/QT5/qt_editor.py @@ -31,8 +31,8 @@ import traceback # Modules Eficas from Accas.extensions.eficas_translation import tr from Editeur import session -from InterfaceGUI.common import comploader -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import comploader +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.QT5 import browser from UiQT5.desBaseWidget import Ui_baseWidget @@ -70,6 +70,11 @@ class QtEditor(Editor, Ui_baseWidget, QWidget): self.QWParent = QWParent Editor.__init__(self, appliEficas, fichier, jdc, include) + + # on enleve la gestion du dicEditor necessaire dans les autres cas + # mais ici l index est le numero de page et non l idUnique + del self.appliEficas.editorManager.dictEditors[self.idUnique] + if self.jdc: comploader.chargerComposants(self.appliEficas.GUIPath) self.jdc_item = objecttreeitem.makeObjecttreeitem(self, "nom", self.jdc) diff --git a/InterfaceGUI/QT5/qt_editor_manager.py b/InterfaceGUI/QT5/qt_editor_manager.py index 44125b73..3bb049c6 100644 --- a/InterfaceGUI/QT5/qt_editor_manager.py +++ b/InterfaceGUI/QT5/qt_editor_manager.py @@ -401,12 +401,12 @@ class QtEditorManager(EditorManager): else: from qt_editor import QtEditor editor = QtEditor(self.appliEficas, fichier, jdc, self.myQtab, include) - if double != None: self.doubles[editor] = double - if editor.jdc: # le fichier est bien un jdc - self.editors.append(editor) - newWin = 1 - else: - editor.closeIt() + if double != None: self.doubles[editor] = double + if editor.jdc: # le fichier est bien un jdc + self.editors.append(editor) + newWin = 1 + else: + editor.closeIt() if newWin: self.addView(editor, fichier) elif editor.jdc: self.myQtab.setCurrentIndex(indexEditor) diff --git a/InterfaceGUI/Web/browser.py b/InterfaceGUI/Web/browser.py index 3e3855ed..14a444f1 100644 --- a/InterfaceGUI/Web/browser.py +++ b/InterfaceGUI/Web/browser.py @@ -32,6 +32,7 @@ class JDCTree(): #---------------------------------------- #print ('__init__ JDCTree') self.editor = editor + #print ('browser', self.editor) self.plie = False self.item = jdc_item self.tree = self @@ -42,6 +43,7 @@ class JDCTree(): self.inhibeExpand = True self.childrenComplete=[] self.oldValidite='init' + self.editor.idUnique = self.tree.racine.item.idUnique #print ('fin __init__ JDCTree') # def handleContextMenu(self,item,coord): @@ -69,6 +71,7 @@ class JDCNode(): self.treeParent = treeParent self.tree = self.treeParent.tree self.editor = self.treeParent.editor + #print ('browser Node', self.editor) self.appliEficas = treeParent.appliEficas self.firstAffiche = True self.childrenComplete=[] @@ -85,6 +88,7 @@ class JDCNode(): self.children = [] self.buildChildren() + self.editor.dicoIdNode[item.idUnique] = item self.item.connect("valid",self.onValid,()) self.item.connect("supp" ,self.onSupp,()) @@ -231,16 +235,13 @@ class JDCNode(): 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): #----------------------------------- """ @@ -271,7 +272,7 @@ class JDCNode(): #else : return None except : txt=' Impossible d ajouter {} en position {}'.format(name, pos) - self.editor.afficheInfos(txt,'rouge') + self.editor.afficheMessage(txt,'rouge') return None if debug : print ('name : ', name, ' a pour index : ', index) obj = mcPere.addEntite(name,index) @@ -288,7 +289,7 @@ class JDCNode(): #else : return None except : txt=' Impossible d ajouter {} en position {}'.format(name, pos) - self.editor.afficheInfos(txt,'rouge') + self.editor.afficheMessage(txt,'rouge') return None if debug : print ('name : ', name, ' a pour index : ', index) obj = self.item.addEntite(name,index) # emet le signal 'add' diff --git a/InterfaceGUI/Web/compobloc.py b/InterfaceGUI/Web/compobloc.py index e5c87c50..fb0c5c94 100644 --- a/InterfaceGUI/Web/compobloc.py +++ b/InterfaceGUI/Web/compobloc.py @@ -19,7 +19,7 @@ # -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.Web import compofact from InterfaceGUI.Web import browser diff --git a/InterfaceGUI/Web/compofact.py b/InterfaceGUI/Web/compofact.py index 2a6b648c..f02d75c6 100644 --- a/InterfaceGUI/Web/compofact.py +++ b/InterfaceGUI/Web/compofact.py @@ -20,7 +20,7 @@ from InterfaceGUI.Web import browser from InterfaceGUI.Web import typeNode -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from Accas.extensions.eficas_translation import tr diff --git a/InterfaceGUI/Web/compojdc.py b/InterfaceGUI/Web/compojdc.py index 52821f2c..90c49a31 100644 --- a/InterfaceGUI/Web/compojdc.py +++ b/InterfaceGUI/Web/compojdc.py @@ -18,7 +18,7 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common.jdc_treeItem_commun import JDCTreeItemCommun from InterfaceGUI.Web import browser from InterfaceGUI.Web import typeNode from Accas.extensions.eficas_translation import tr @@ -30,93 +30,8 @@ class Node(browser.JDCNode,typeNode.PopUpMenuRacine): return param -class JDCTreeItem(objecttreeitem.ObjectTreeItem): +class JDCTreeItem(JDCTreeItemCommun): 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 diff --git a/InterfaceGUI/Web/compomclist.py b/InterfaceGUI/Web/compomclist.py index 0403ff31..34637217 100644 --- a/InterfaceGUI/Web/compomclist.py +++ b/InterfaceGUI/Web/compomclist.py @@ -23,7 +23,7 @@ from InterfaceGUI.Web import browser from InterfaceGUI.Web import typeNode from Accas.extensions.eficas_translation import tr -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from Accas.processing.P_OBJECT import ErrorObj diff --git a/InterfaceGUI/Web/compooper.py b/InterfaceGUI/Web/compooper.py index 7ce84364..834d9961 100644 --- a/InterfaceGUI/Web/compooper.py +++ b/InterfaceGUI/Web/compooper.py @@ -20,7 +20,7 @@ from Accas.extensions.eficas_translation import tr from Accas.extensions.eficas_exception import EficasException -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.Web import browser from InterfaceGUI.Web import typeNode diff --git a/InterfaceGUI/Web/compoparam.py b/InterfaceGUI/Web/compoparam.py index 47892f7a..f2847050 100644 --- a/InterfaceGUI/Web/compoparam.py +++ b/InterfaceGUI/Web/compoparam.py @@ -1,5 +1,5 @@ # -*- coding: utf-8 -*- -# Copyright (C) 2007-2021 EDF R&D +# 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 @@ -25,113 +25,17 @@ # import modules EFICAS -from InterfaceGUI.common import objecttreeitem -from InterfaceGUI.Web import browser +from InterfaceGUI.Common.param_treeItem_commun import PARAMTreeItemCommun from InterfaceGUI.Web import typeNode +from InterfaceGUI.Web import browser from Accas.extensions.eficas_translation import tr +from Accas.extensions.parametre import PARAMETRE +class Node(browser.JDCNode, typeNode.PopUpMenuNodePartiel): + pass -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") +class PARAMTreeItem(PARAMTreeItemCommun): + itemNode = Node -import Accas.extensions.parametre -treeitem =PARAMTreeItem -objet = Accas.extensions.parametre.PARAMETRE +treeitem = PARAMTreeItem +objet = PARAMETRE diff --git a/InterfaceGUI/Web/compoproc.py b/InterfaceGUI/Web/compoproc.py index f793cc46..b7f3aa4b 100644 --- a/InterfaceGUI/Web/compoproc.py +++ b/InterfaceGUI/Web/compoproc.py @@ -17,7 +17,7 @@ # # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.Web import compooper from InterfaceGUI.Web import browser from InterfaceGUI.Web import typeNode diff --git a/InterfaceGUI/Web/composimp.py b/InterfaceGUI/Web/composimp.py index ead37971..5eefd20d 100644 --- a/InterfaceGUI/Web/composimp.py +++ b/InterfaceGUI/Web/composimp.py @@ -21,16 +21,13 @@ import traceback # Modules Eficas -from InterfaceGUI.common import objecttreeitem -from Accas.processing.P_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.common.politiquesValidation import PolitiqueUnique -from InterfaceGUI.common.politiquesValidation import PolitiquePlusieurs +from InterfaceGUI.Common.politiquesValidation import PolitiqueUnique +from InterfaceGUI.Common.politiquesValidation import PolitiquePlusieurs +from InterfaceGUI.Common import objecttreeitem +from InterfaceGUI.Common.simp_treeItem_commun import SIMPTreeItemCommun + class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal): @@ -46,571 +43,11 @@ class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal): 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 - +class SIMPTreeItem(SIMPTreeItemCommun): + itemNode = Node import Accas treeitem = SIMPTreeItem objet = Accas.MCSIMP + + diff --git a/InterfaceGUI/Web/defi b/InterfaceGUI/Web/defi new file mode 100644 index 00000000..e09a51ad --- /dev/null +++ b/InterfaceGUI/Web/defi @@ -0,0 +1,11 @@ + def __init__(self,code, fichierCata=None, langue=None, fichierComm=None,appWeb=None) : + def toWebApp(self,fction,*args, **kwargs): + def litFichierComm(self,fichierComm=None): + def getListeCommandes(self): + def getListeMotsClesFilsPossibles(self,nomCommande): + def getDicoForFancy(self,obj,debug=0) : + def changeValeur(self,id,valeur) : + def updateSDName(self,id,sdnom) : + def suppNode(self,id): + def appendChild(self,id,name,pos=None): + def saveFile(self,fileName): diff --git a/InterfaceGUI/Web/web_editor.py b/InterfaceGUI/Web/web_editor.py index 34b69b6c..9ac4982b 100755 --- a/InterfaceGUI/Web/web_editor.py +++ b/InterfaceGUI/Web/web_editor.py @@ -27,9 +27,11 @@ import traceback # Modules Eficas from Accas.extensions.eficas_translation import tr from Accas.extensions.eficas_exception import EficasException +from Editeur.loggingEnvironnement import loggingEnvironnement, fonctionLoguee -from InterfaceGUI.common import comploader -from InterfaceGUI.common import objecttreeitem + +from InterfaceGUI.Common import comploader +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.Web import browser debug = False @@ -49,23 +51,26 @@ class WebEditor(Editor): #-------------------------------------------------------------------------- self.connecteur=appliEficas - Editor.__init__(self,appliEficas,fichier) self.dicoIdNode={} + Editor.__init__(self,appliEficas,fichier) comploader.chargerComposants('Web') self.tree=None if self.jdc: - self.jdc_item=objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc ) + self.jdc_item=objecttreeitem.makeObjecttreeitem( appliEficas, "nom", self.jdc ) if self.jdc_item : self.tree = browser.JDCTree( self.jdc_item, self ) + #----------------------------- + @fonctionLoguee def getNodeById(self,nodeId ): #----------------------------- if nodeId in self.dicoIdNode : return self.dicoIdNode[nodeId] else : return None #--------------------------------------- + @fonctionLoguee def reconstruitChaineDIndex(self,nodeId): #--------------------------------------- """ utilise pour logguer les fonctions """ @@ -85,25 +90,54 @@ class WebEditor(Editor): #----------------------------- + @fonctionLoguee def getDicoForFancy(self,obj) : #----------------------------- if self.tree == None : return {} return obj.getDicoForFancy() #------------------------------------- + @fonctionLoguee def afficheMessage(self,txt,couleur=None): #--------------------------------------- self.connecteur.toWebApp('afficheMessage', txt, couleur) Editor.afficheMessage(self,'message to webapp',txt,couleur) #------------------------------------- + @fonctionLoguee def afficheAlerte(self,titre,message): #------------------------------------- self.connecteur.toWebApp('afficheAlerte', titre , message) Editor.afficheMessage(self,titre,message) #--------------------------- + @fonctionLoguee def getListeCommandes(self): #--------------------------- return (self.jdc.getListeCmd()) + #--------------------------------- + @fonctionLoguee + def updateSDName(self,id,sdnom) : + #--------------------------------- + monNode=self.getNodeById(id) + if not monNode : return (False, 'Node {} non trouve'.format(id)) + return monNode.fauxNoeudGraphique.updateSDName(sdnom) + + #--------------------------------- + @fonctionLoguee + def changeValeur(self,id,valeur) : + #--------------------------------- + """ + id : identifiant unique + valeur : valeur saisie dans le formulaire + doit-on mettre l ancienne valeur en retour qui serait utile si validité = Non + """ + monNode=self.getNodeById(id) + if not monNode : return (id, False, 'Node {} non trouve'.format(id)) + #print (' change Valeur', monNode) + #(idUnique, commentaire, validite)=monNode.fauxNoeudGraphique.traiteValeurSaisie(valeur) + #print ('retour ChangeValeur',idUnique, commentaire, validite ) + # + return monNode.fauxNoeudGraphique.traiteValeurSaisie(valeur) + diff --git a/InterfaceGUI/Web/web_editor_manager.py b/InterfaceGUI/Web/web_editor_manager.py index ab70df2d..74c0b3c5 100644 --- a/InterfaceGUI/Web/web_editor_manager.py +++ b/InterfaceGUI/Web/web_editor_manager.py @@ -33,7 +33,8 @@ class WebEditorManager(EditorManager): def __init__(self, appliEficas): #-------------------------------- super().__init__(appliEficas) - self.dictSessions={} + self.dictEditors={} + self.dictSessions = {} #--------------------------------------- @@ -59,14 +60,33 @@ class WebEditorManager(EditorManager): editor = self.dictEditors[indexEditor] if self.samePath(fichier, editor.getFileName()): double = editor - + break else: + double = None from web_editor import WebEditor editor = WebEditor(self.appliEficas, fichier) if editor.jdc: # le fichier est bien un jdc self.editors.append(editor) + self.dictEditors[editor.idUnique]=editor else: editor=None + # if double : + # il faut mettre les sessions à jours return editor + # -------------------------- + def getEditorById(self, id): + # --------------------------- + if id in self.dictEditors: + return self.dictEditors[id] + return None + + # -------------------------- + def getIdByEditor(self, editor): + # --------------------------- + for (id, valEditor) in self.dictEditors.items(): + if editor == valEditor : return id + return None + + diff --git a/InterfaceGUI/cinqC/compofact.py b/InterfaceGUI/cinqC/compofact.py index 8b7a7978..7d56e5e9 100644 --- a/InterfaceGUI/cinqC/compofact.py +++ b/InterfaceGUI/cinqC/compofact.py @@ -23,7 +23,7 @@ from InterfaceGUI.QT5 import typeNode from Accas.extensions.eficas_translation import tr -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem import traceback diff --git a/InterfaceGUI/cinqC/compojdc.py b/InterfaceGUI/cinqC/compojdc.py index e27b3c84..262aabdf 100644 --- a/InterfaceGUI/cinqC/compojdc.py +++ b/InterfaceGUI/cinqC/compojdc.py @@ -18,7 +18,7 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.cinqC import browser from Accas.extensions.eficas_translation import tr diff --git a/InterfaceGUI/cinqC/compomclist.py b/InterfaceGUI/cinqC/compomclist.py index 7499c113..e1b7b6e6 100644 --- a/InterfaceGUI/cinqC/compomclist.py +++ b/InterfaceGUI/cinqC/compomclist.py @@ -26,7 +26,7 @@ from InterfaceGUI.cinqC import browser from InterfaceGUI.QT5 import typeNode from Accas.extensions.eficas_translation import tr -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from Accas.processing.P_OBJECT import ErrorObj diff --git a/InterfaceGUI/cinqC/compooper.py b/InterfaceGUI/cinqC/compooper.py index e5a824f7..38e02aee 100644 --- a/InterfaceGUI/cinqC/compooper.py +++ b/InterfaceGUI/cinqC/compooper.py @@ -20,7 +20,7 @@ import os import tempfile -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.cinqC import browser class Node(browser.JDCNode ): diff --git a/InterfaceGUI/cinqC/composimp.py b/InterfaceGUI/cinqC/composimp.py index 1fe7da53..7aea9734 100644 --- a/InterfaceGUI/cinqC/composimp.py +++ b/InterfaceGUI/cinqC/composimp.py @@ -18,7 +18,7 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -from InterfaceGUI.common import objecttreeitem +from InterfaceGUI.Common import objecttreeitem from InterfaceGUI.cinqC import browser from InterfaceGUI.QT5.compojdc import JDCTreeItem diff --git a/InterfaceGUI/common/comploader.py b/InterfaceGUI/common/comploader.py deleted file mode 100644 index e8ffe05e..00000000 --- a/InterfaceGUI/common/comploader.py +++ /dev/null @@ -1,105 +0,0 @@ -# -*- 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 -# -""" - Module de chargement des composants et de mapping des objets du processing - Accas vers les items d'EFICAS - - - composants : dictionnaire de stockage des relations entre types - d'objet du processing et types d'item - - chargerComposants() : fonction de chargement des composants. Retourne - le dictionnaire composants. - - gettreeitem(object) -> type d'item : fonction qui retourne un type - d'item correspondant au type de l'objet processing fourni. - - makeObjecttreeitem(appliEficas,labeltext, object, setFunction=None) -> item : fonction qui retourne un item - correspondant a l'objet processing fourni. -""" -import os, glob, types - -# Dictionnaire {object : item} permettant d'associer un item a un object -# Ce dictionnaire est renseigne par la methode chargerComposants -composants = {} - - -def chargerComposants(GUIPath): - """ - Cette fonction a pour but de charger tous les modules composants graphiques - (fichiers compo*.py dans le meme repertoire que ce module ) - et de remplir le dictionnaire composants utilise par makeObjecttreeitem - """ - debug = 0 - ici=os.path.dirname(os.path.abspath(__file__)) - if debug : print ('GUIPath') - repertoire = os.path.join(ici,"../..", "InterfaceGUI",GUIPath) - if debug : print ('repertoire', repertoire) - package = 'InterfaceGUI.'+GUIPath - listfich = glob.glob(os.path.join(repertoire, "compo*.py")) - if debug : print ('listfich', listfich) - for fichier in listfich: - if debug : print (fichier) - m = os.path.basename(fichier)[:-3] - module = __import__(package, globals(), locals(), [m]) - module = getattr(module, m) - composants[module.objet] = module.treeitem - if debug: - print("fin chargerComposants, composants : ", composants) - return composants - - -def gettreeitem(object): - """ - Cette fonction retourne la classe item associee a l'objet object. - Cette classe item depend bien sur de la nature de object, d'ou - l'interrogation du dictionnaire composants - """ - # Si la definition de l'objet a un attribut itemeditor, il indique - # la classe a utiliser pour l'item - try: - return object.definition.itemeditor - except: - pass - - try: - itemtype = composants[object.__class__] - return itemtype - except: - pass - - # Puis une eventuelle classe heritee (aleatoire car sans ordre) - for e in list(composants.keys()): - if e and isinstance(object, e): - itemtype = composants[e] - return itemtype - - # Si on n'a rien trouve dans les composants on utilise l'objet par defaut - # fonctionnalite qui n est pas developpee : composants[None] n existe pas - itemtype = composants[None] - return itemtype - - -def makeObjecttreeitem(appliEficas, labeltext, object, setFunction=None): - """ - Cette fonction permet de construire et de retourner un objet - de type item associe a l'object passe en argument. - """ - debug = 0 - if debug: - print(appliEficas, labeltext, object, setFunction) - c = gettreeitem(object) - return c(appliEficas, labeltext, object, setFunction) diff --git a/InterfaceGUI/common/objecttreeitem.py b/InterfaceGUI/common/objecttreeitem.py deleted file mode 100644 index 81338a1f..00000000 --- a/InterfaceGUI/common/objecttreeitem.py +++ /dev/null @@ -1,551 +0,0 @@ -# -*- coding: utf-8 -*- -# Copyright (C) 2007-2024 EDF R&D -# -# This library is free software; you can redistribute it and/or -# modify it under the terms of the GNU Lesser General Public -# License as published by the Free Software Foundation; either -# version 2.1 of the License. -# -# This library is distributed in the hope that it will be useful, -# but WITHOUT ANY WARRANTY; without even the implied warranty of -# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -# Lesser General Public License for more details. -# -# You should have received a copy of the GNU Lesser General Public -# License along with this library; if not, write to the Free Software -# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -# -# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com -# -""" -""" -from builtins import str -from builtins import object -import types, os, sys -from copy import copy, deepcopy -from uuid import uuid1 - -# import du chargeur de composants -from InterfaceGUI.common.comploader import makeObjecttreeitem -from Accas.accessor import CONNECTOR -from Accas.extensions.eficas_translation import tr -from Accas.extensions.eficas_exception import EficasException - -from reprlib import Repr - -myrepr = Repr() -myrepr.maxstring = 100 -myrepr.maxother = 100 - - -class TreeItem(object): - - """Abstract class representing tree items. - - Methods should typically be overridden, otherwise a default action - is used. - - """ - - # itemNode est une factory qui doit retourner un objet de la classe Node - # ou derive de cette classe. - # Le widget arbre utilisera cet objet comme noeud associe au tree item. - # Par defaut, utilise la classe Node de base - # La signature de la factory est la suivante : - # itemNode(treeOrNode,item,command,rmenu) - # ou treeOrNode est le noeud parent, item est l'item associe - # command est une fonction python appelee sur selection graphique - # du noeud et rmenu est une fonction python appelee sur click droit sur le noeud - itemNode = None - - def __init__(self): - """Constructor. Do whatever you need to do.""" - - def getText(self): - """Return text string to display.""" - - def getLabelText(self): - """Return label text string to display in front of text (if any).""" - - expandable = None - - def _isExpandable(self): - if self.expandable is None: - self.expandable = self.isExpandable() - return self.expandable - - def isExpandable(self): - """Return whether there are subitems.""" - return 1 - - def _getSubList(self): - """Do not override! Called by TreeNode.""" - if not self.isExpandable(): - return [] - sublist = self.getSubList() - if not sublist: - self.expandable = 0 - return sublist - - def IsEditable(self): - """Return whether the item's text may be edited.""" - pass - - def SetText(self, text): - """Change the item's text (if it is editable).""" - pass - - def getIconName(self): - """Return name of icon to be displayed normally.""" - pass - - def getSelectedIconName(self): - """Return name of icon to be displayed when selected.""" - pass - - def getSubList(self): - """Return list of items forming sublist.""" - pass - - def onDoubleClick(self): - """Called on a double-click on the item.""" - pass - - -class Delegate(object): - def __init__(self, delegate=None): - self.object = delegate - self.__cache = {} - - def setDelegate(self, delegate): - self.resetcache() - self.object = delegate - - def getDelegate(self): - return self.object - - def __getattr__(self, name): - attr = getattr(self.object, name) # May raise AttributeError - setattr(self, name, attr) - self.__cache[name] = attr - return attr - - def resetcache(self): - for key in list(self.__cache.keys()): - try: - delattr(self, key) - except AttributeError: - pass - self.__cache.clear() - - def cachereport(self): - keys = list(self.__cache.keys()) - keys.sort() - # print keys - - -class ObjectTreeItem(TreeItem, Delegate): - def __init__(self, appliEficas, labeltext, object, setFunction=None): - self.labeltext = labeltext - self.appliEficas = appliEficas - # L'objet delegue est stocke dans l'attribut object - # L'objet associe a l'item est stocke dans l'attribut _object - # Il peut etre obtenu par appel a la methode getObject - # Attention : le delegue peut etre different de l'objet associe (MCLIST) - # Dans le cas d'une MCListe de longueur 1, l'objet associe est la MCListe - # et l'objet delegue est le MCFACT (object = _object.data[0]) - Delegate.__init__(self, object) - # On cache l'objet initial (pour destruction eventuelle - # ulterieure) - self._object = object - self.setFunction = setFunction - self.expandable = 1 - self.sublist = [] - self.init() - - - # La partie suivante ne sert que pour le Web - # on met le meme id au noeud et a l objet - # utile pour les MCList - if hasattr(object, "idUnique"): - self.idUnique = object.idUnique - else: - self.idUnique = uuid1().hex - - if self._object.nature == "MCList" and len(self._object.data) == 1: - # pour les suppressions on met le meme id a l objet et a la liste - self._object.data[0].idUnique = self.idUnique - self._object.idUnique = self._object.data[0].idUnique - if hasattr(self.appliEficas, "dicoIdNode"): - self.appliEficas.dicoIdNode[self._object.data[0].idUnique] = self - self.idUnique = 0 - return - - self._object.idUnique = self.idUnique - if hasattr(self.appliEficas, "dicoIdNode") and self.idUnique: - self.appliEficas.dicoIdNode[self.idUnique] = self - - def init(self): - return - - def getObject(self): - return self._object - - def connect(self, channel, callable, args): - """Connecte la fonction callable (avec arguments args) a l'item self sur le - canal channel - """ - # print self,channel,callable,args - CONNECTOR.Connect(self._object, channel, callable, args) - CONNECTOR.Connect(self.object, channel, callable, args) - - def copy(self): - """ - Cree un item copie de self - """ - object = self._object.copy() - appliEficas = copy(self.appliEficas) - labeltext = copy(self.labeltext) - fonction = deepcopy(self.setFunction) - item = makeObjecttreeitem(appliEficas, labeltext, object, fonction) - return item - - def isActif(self): - if hasattr(self.object, "actif"): - return self.object.actif - else: - return 1 - - def update(self, item): - """ - Met a jour l'item courant a partir d'un autre item passe en argument - Ne fait rien par defaut - """ - pass - - def getLabelText(self): - """Retourne 3 valeurs : - - le texte a afficher dans le noeud representant l'item - - la fonte dans laquelle afficher ce texte - - la couleur du texte - """ - # None --> fonte et couleur par defaut - return tr(self.labeltext), None, None - - def getNature(self): - """ - Retourne la nature de l'item et de l'objet - """ - return self.object.nature - - def getRegles(self): - """retourne les regles de l'objet pointe par self""" - return self.object.getRegles() - - def getListeMcPresents(self): - """Retourne la liste des mots-cles fils de l'objet pointe par self""" - return self.object.listeMcPresents() - - def getVal(self): - """Retourne le nom de la valeur de l'objet pointe par self dans le cas - ou celle-ci est un objet (ASSD)""" - return self.object.getVal() - - def get_definition(self): - """ - Retourne l'objet definition de l'objet pointe par self - """ - return self.object.definition - - def getListeMcOrdonnee(self, liste, dico): - """retourne la liste ordonnee (suivant le catalogue) brute des mots-cles - d'une entite composee dont le chemin complet est donne sous forme - d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... - il faut encore rearranger cette liste (certains mots-cles deja - presents ne doivent plus etre proposes, regles ...)""" - return self.object.getListeMcOrdonnee(liste, dico) - - def getListeMcOrdonneeBrute(self, liste, dico): - """ - retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles - d'une entite composee dont le chemin complet est donne sous forme - d'une liste du type :ETAPE + MCFACT ou MCBLOC + ... - """ - return self.object.getListeMcOrdonneeBrute(liste, dico) - - def getGenealogie(self): - """ - Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC ou ETAPE) - de l'objet pointe par self - """ - return self.object.getGenealogie() - - def getIndexChild(self, nom_fils): - """ - Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils - Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter - le nouveau mot-cle - """ - return self.object.getIndexChild(nom_fils) - - def getIndexChild_old(self, nom_fils): - """ - Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils - Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter - le nouveau mot-cle - """ - liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute( - self.getGenealogie(), self.getJdc().dicoCataOrdonne - ) - liste_noms_mc_presents = self.object.listeMcPresents() - l = [] - for nom in liste_noms_mc_ordonnee: - if nom in liste_noms_mc_presents or nom == nom_fils: - l.append(nom) - # l contient les anciens mots-cles + le nouveau dans l'ordre - return l.index(nom_fils) - - def appendChild(self, name, pos=None): - """ - Permet d'ajouter un item fils a self - """ - if pos == "first": - index = 0 - elif pos == "last": - index = len(self.listeMcPresents()) - elif type(pos) == int: - # la position est fixee - index = pos - # elif type(pos) == types.InstanceType: - elif type(pos) == object: - # pos est un item. Il faut inserer name apres pos - index = self.getIndex(pos) + 1 - # elif type(name) == types.InstanceType: - elif type(name) == object: - index = self.getIndexChild(name.nom) - else: - index = self.getIndexChild(name) - return self.addobject(name, index) - - def appendBrother(self, name, pos="after"): - """ - Permet d'ajouter un frere a self - par defaut on l'ajoute apres self - """ - index = self._object.parent.getIndex(self.getObject()) - if pos == "before": - index = index - elif pos == "after": - index = index + 1 - else: - print((tr("%d n'est pas un index valide pour appendBrother", pos))) - return - return self.parent.addobject(name, index) - - def getCopieObjet(self): - """Retourne une copie de l'objet pointe par self""" - return self.object.copy() - - def getPosition(self): - """Retourne la valeur de l'attribut position de l'objet pointe par self""" - definition = self.get_definition() - try: - return getattr(definition, "position") - except AttributeError: - return "local" - - def getNom(self): - """Retourne le nom de l'objet pointe par self""" - return self.object.nom - - def getJdc(self): - """Retourne le jdc auquel appartient l'objet pointe par self""" - return self.object.jdc - - def getValeur(self): - """Retourne la valeur de l'objet pointe par self""" - return self.object.valeur - - def getCr(self): - """Retourne le compte-rendu CR de self""" - return self.object.report() - - def getObjetCommentarise(self): - """ - Cette methode retourne un objet commentarise - representatif de self.object - --> a surcharger par les differents items - """ - raise EficasException( - "MESSAGE AU DEVELOPPEUR : il faut \ - surcharger la methode getObjetCommentarise() \ - pour la classe %s", - self.__class__.__name__, - ) - - def isValid(self): - """Retourne 1 si l'objet pointe par self est valide, 0 sinon""" - return self.object.isValid() - - def isCopiable(self): - """ - Retourne 1 si l'objet est copiable, 0 sinon - Par defaut retourne 0 - """ - return 0 - - def getMcPresents(self): - """Retourne le dictionnaire des mots-cles presents de l'objet pointe par self""" - return self.object.dictMcPresents() - - def verifConditionRegles(self, l_mc_presents): - return self.object.verifConditionRegles(l_mc_presents) - - def getFr(self): - """Retourne le fr de l'objet pointe par self""" - try: - return self.object.getFr() - except: - return "" - - def getDocu(self): - """Retourne la cle de doc de l'objet pointe par self""" - return self.object.getDocu() - - def setValeur(self, new_valeur): - """Remplace la valeur de l'objet pointe par self par new_valeur""" - return self.object.setValeur(new_valeur) - - def getText(self): - return myrepr.repr(self.object) - - def getIconName(self): - if not self.isExpandable(): - return "python" - - def IsEditable(self): - return self.setFunction is not None - - def SetText(self, text): - try: - value = eval(text) - self.setFunction(value) - except: - pass - - def isExpandable(self): - return 1 - - def getSubList(self): - keys = dir(self.object) - sublist = [] - for key in keys: - try: - value = getattr(self.object, key) - except AttributeError: - continue - item = makeObjecttreeitem( - self.appliEficas, - str(key) + " =", - value, - lambda value, key=key, object=self.object: setattr(object, key, value), - ) - sublist.append(item) - return sublist - - # a piori inutile PN 06 11 17 - # def wait_fichier_init(self): - """ Retourne 1 si l'object pointe par self attend un fichier d'initialisation - (ex: macros POURSUITE et INCLUDE de Code_Aster), 0 SINON """ - - # return self.object.definition.fichier_ini - - def makeObjecttreeitem(self, appliEficas, labeltext, object, setFunction=None): - """ - Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet - de type item associe a l'object passe en argument. - """ - return makeObjecttreeitem(appliEficas, labeltext, object, setFunction) - - # def __del__(self): - # print "__del__",self - - -class AtomicObjectTreeItem(ObjectTreeItem): - def isExpandable(self): - return 0 - - -class SequenceTreeItem(ObjectTreeItem): - def isExpandable(self): - return len(self._object) > 0 - - def __len__(self): - return len(self._object) - - def keys(self): - return list(range(len(self._object))) - - def getIconName(self): - if self._object.isValid(): - return "ast-green-los" - elif self._object.isOblig(): - return "ast-red-los" - else: - return "ast-yel-los" - - def ajoutPossible(self): - return self._object.ajoutPossible() - - def getIndex(self, child): - """Retourne le numero de child dans la liste des enfants de self""" - return self._object.getIndex(child.getObject()) - - def getText(self): - return " " - - def addItem(self, obj, pos): - self._object.insert(pos, obj) - item = self.makeObjecttreeitem(self.appliEficas, obj.nom + ":", obj) - return item - - def suppItem(self, item): - try: - self._object.remove(item.getObject()) - # la liste peut etre retournee vide ! - message = "Mot-clef " + item.getObject().nom + " supprime" - self.appliEficas.afficheMessages(message) - return 1 - except: - return 0 - - def getSubList(self): - isublist = iter(self.sublist) - liste = self._object.data - iliste = iter(liste) - self.sublist = [] - - while 1: - old_obj = obj = None - for item in isublist: - old_obj = item.getObject() - if old_obj in liste: - break - - for obj in iliste: - if obj is old_obj: - break - - # nouvel objet : on cree un nouvel item - def setFunction(value, object=obj): - object = value - - it = self.makeObjecttreeitem( - self.appliEficas, obj.nom + " : ", obj, setFunction - ) - self.sublist.append(it) - if old_obj is None and obj is None: - break - if old_obj is obj: - self.sublist.append(item) - return self.sublist diff --git a/InterfaceGUI/common/politiquesValidation.py b/InterfaceGUI/common/politiquesValidation.py deleted file mode 100644 index 043c6409..00000000 --- a/InterfaceGUI/common/politiquesValidation.py +++ /dev/null @@ -1,333 +0,0 @@ -# -*- 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 Accas.extensions.eficas_translation 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__(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") - 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 diff --git a/InterfaceGUI/common/traiteSaisie.py b/InterfaceGUI/common/traiteSaisie.py deleted file mode 100644 index c2a93a1a..00000000 --- a/InterfaceGUI/common/traiteSaisie.py +++ /dev/null @@ -1,181 +0,0 @@ -# -*- 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 Accas.extensions.eficas_translation 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.afficheMessage(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.afficheMessage("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.afficheMessage(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.afficheMessage(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.afficheMessage(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() diff --git a/Web/accasConnecteur.py b/Web/accasConnecteur.py index 6ebb80ef..a7328151 100644 --- a/Web/accasConnecteur.py +++ b/Web/accasConnecteur.py @@ -49,11 +49,11 @@ class AccasConnecteur : self.monEficas=getEficasSsIhm(code=code, salome=0, multi=multi, langue=langue,fichierCata=fichierCata, GUIPath='Web') if self.monEficas == None : - self.toWebApp('afficheInfos', 'erreur à la construction de l appli Eficas', 'rouge') + self.toWebApp('afficheMessage', 'erreur à la construction de l appli Eficas', 'rouge') return # faire l equivalent du editorManager if fichierCata == None and fichierComm : - self.toWebApp('afficheInfos', 'pour ouvrir un JDC, il faut connaitre le catalogue', 'rouge') + self.toWebApp('afficheMessage', 'pour ouvrir un JDC, il faut connaitre le catalogue', 'rouge') return self.litFichierComm(fichierComm) diff --git a/Web/mdm2.py b/Web/mdm2.py new file mode 100755 index 00000000..b077b02a --- /dev/null +++ b/Web/mdm2.py @@ -0,0 +1,409 @@ +# coding: utf-8 +#!/usr/bin/env python3 +import sys + +code='Essai' +#code=None + +from flask import Flask, request, render_template, url_for, jsonify, make_response, session, g, Response + + +# File management +from flask import redirect, send_from_directory +from werkzeug.utils import secure_filename +from lib.upload_file import uploadfile +import PIL +from PIL import Image +import simplejson +import traceback + +# from flask import ?? json, jsonify ?? +import json +import os +from pprint import pprint +from collections import OrderedDict +from markupsafe import escape + +# Flask management of Server Side Event +from flask_sse import sse + +app = Flask(__name__) +app.secret_key = 'EssaiPN' + +# CATALOGS_EXT=("py","jpg") #TODO : supprimer jpg pour test +# catalogs = UploadSet("catalogs",CATALOGS_EXT) +# app.config["UPLOADED_CATALOGS_DEST"] = "data/catalogs" +# app.config["SECRET_KEY"] = os.urandom(24) + +# configure_uploads(app, catalogs) + +app.config['SECRET_KEY'] = os.urandom(24) +app.config['UPLOAD_FOLDER'] = 'data/' +app.config['THUMBNAIL_FOLDER'] = 'data/thumbnail/' +app.config['MAX_CONTENT_LENGTH'] = 50 * 1024 * 1024 +ALLOWED_EXTENSIONS = set(['py','comm','txt', 'gif', 'png', 'jpg', 'jpeg', 'bmp', 'rar', 'zip', '7zip', 'doc', 'docx']) +IGNORED_FILES = set(['.gitignore']) + + +### Server Side Event config +app.config["REDIS_URL"] = "redis://localhost" +#app.config["REDIS_URL"] = "redis://:password@localhost" +#TODO: personaliser l'url en fonction de la session utilisateur +app.register_blueprint(sse, url_prefix='/stream') + + +### Eficas Connector +def createWebAppli(app): + import os + sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..')) + from Editeur.eficas_go import getEficas + eficasAppli=getEficas(code, langue='ang',GUIPath= 'Web',appWeb=app) + return eficasAppli + + +eficasAppli=createWebAppli(app) +debug=1 +if debug : + monEficasEditeur=eficasAppli.getEditor() + print ('les commandes dans le catalogue') + print ('_______________________________') + print (monEficasEditeur.getListeCommandes()) + +def fromConnecteur(maFonction,*args,**kwargs): + fnct=globals()[maFonction] + fnct(*args,**kwargs) + +#TODO : Rattacher à une session +# gérer un appel register callback +app.fromConnecteur=fromConnecteur + +## ServerSideEvent from Eficas signals : +# - Validite +# - Ajouter un noeud (et ses enfants) +# - Supprimer un noeud (et ses enfants), +# - ReAffichage d'un noeud (et ses enfants) +# - Changement d'un nom de mot-cle reference + +def propageValide(id, valid): #TODO: RENAME TO ... propagateValidation + print ('Flask/propageValide: ', id, valid) + sse.publish( {'id':id, 'valid':valid, 'message': "Hello from propageValide!"}, type='propageValide') + +def updateNodeInfo(id, info): + print ('Flask/updateNodeInfo: ', id, info) + sse.publish( {'id':id, 'info':info, 'message': "Hello from updateNodeInfo!"}, type='updateNodeInfo') + +def appendChildren(id, fcyTreeJson, pos): + print ('Flask/appendChildren: ', id, fcyTreeJson, pos) + sse.publish( {'id':id, 'fcyTreeSrc':fcyTreeJson, 'pos':pos, 'message': "Hello from appendChildren!"}, type='appendChildren') + +def deleteChildren(idList): + #print ('Flask/deleteChildren: ', idList) + sse.publish( {'idList':idList,'message': "Hello from deleteChildren!"}, type='deleteChildren') + +#TODO: Câbler la sélection du catalogue avant d'activer les appels suivants +# car si la page Web n'est pas rendue et que le connecteur génère une erreur... boom ! +def afficheMessage(txt, couleur): #TODO: RENAME TO ... displayWarning + print ('Flask/afficheMessage: ', txt, couleur) + # sse.publish( {'txt':txt, 'color':couleur, 'messageClass':"alert-warning" ,'message': "Hello from afficheMessage!"}, + # type='displayMessage') + +def afficheAlerte(titre, message): #TODO: RENAME TO ... displayDanger + print ('Flask/afficheAlerte: ', titre, message) #TODO: titre & message VS txt ? + # sse.publish( {'txt':titre, 'color':couleur, 'messageClass':"alert-danger", 'message': "Hello from afficheAlerte!"}, + # type='displayMessage') + + + +## WebApp -> Eficas : +# Pour SIMP : Ajoute, Supprime (MC facultatif), Change la valeur +# Pour FACT : Ajoute, Supprime +# Pour PROC : Ajoute, Supprime +# Pour OPER : Ajoute, Supprime, Nomme, Renomme +# @app.route('/post/') +@app.route("/updateSimp", methods=['POST']) +def updateSimp(): + # Validate the request body contains JSON + if request.is_json: + # Parse the JSON into a Python dictionary + req = request.get_json() + # Print the dictionary + print("Flask/updateSimp request : ", req) + print("Flask/updateSimp request['id'] : ",req['id']) + id=req['id'];value=req['value'] + # id, value = req.values() # Dangereux correspondance implicite + value = str(value) #On peut écrire Pi + eficasEditeur=eficasAppli.getEditorById(session['eficasEditeur']) + rId,message,changeDone = eficasEditeur.changeValeur(id,value); + assert(rId==id) + #changeDone = True + print ("changeDone : ",changeDone) + # Ne pas recuperer et ne pas renvoyer le noeud dans le cas du SIMP + # (le changeDone et l''ancienne valeur ds la WebApp suffit + node = eficasEditeur.getDicoForFancy(eficasEditeur.getNodeById(id)) + print("Flask/updateSimp node : ",node) + # return jsonify([myTreeDico]) + + return make_response(json.dumps( {'source':node, 'changeIsAccepted' : changeDone, 'message': message} )) + # Return a string along with an HTTP status code + # return "JSON received!", 200 + else: + # The request body wasn't JSON so return a 400 HTTP status code + return "Request was not JSON", 400 + #return make_response(jsonify({"message": "Request body must be JSON"}), 400) + +@app.route("/updateSDName", methods=['POST']) +def updateSDName(): + # Validate the request body contains JSON + if request.is_json: + # Parse the JSON into a Python dictionary + req = request.get_json() + # Print the dictionary + id=req['id'];sdnom=req['sdnom'] + sdnom = str(sdnom) #On peut écrire Pi + eficasEditeur=eficasAppli.getEditorById(session['eficasEditeur']) + changeDone,message = eficasEditeur.updateSDName(id,sdnom); + #changeDone = True + print ("changeDone : ",changeDone) + + #return make_response(json.dumps( {'id':id , 'changeIsAccepted' : changeDone, 'message': message} )) + return make_response(json.dumps( {'changeIsAccepted' : changeDone, 'message': message} )) + # Return a string along with an HTTP status code + # return "JSON received!", 200 + else: + # The request body wasn't JSON so return a 400 HTTP status code + return "Request was not JSON", 400 + #return make_response(jsonify({"message": "Request body must be JSON"}), 400) + + +@app.route("/removeNode", methods=['POST']) +def removeNode(): + # Validate the request body contains JSON + if request.is_json: + # Parse the JSON into a Python dictionary + req = request.get_json() + # Print the dictionary + print("/removeNode ",req);print("/removeNode ",req['id']); + id = req['id']; + eficasEditeur=eficasAppli.getEditorById(session['eficasEditeur']) + ret,message = eficasEditeur.suppNode(id); + print ("/removeNode : ret : ",ret," message : ",message) + + return make_response(json.dumps( {'ret':ret, 'message':message} )) + else: + # The request body wasn't JSON so return a 400 HTTP status code + return "Request was not JSON", 400 + #return make_response(jsonify({"message": "Request body must be JSON"}), 400) + +@app.route("/appendChild", methods=['POST']) +def appendChild(): + # Validate the request body contains JSON + if request.is_json: + # Parse the JSON into a Python dictionary + req = request.get_json() + # Print the dictionary + print(__file__+"/appendChild : ",req); + id=req['id'];name=req['name'];pos=req['pos']; + # id, value = req.values() # Dangereux correspondance implicite + #rId,message,changeDone = eficasEditeur.appendChild(id,name,pos); + newId = eficasEditeur.appendChild(id,name,pos); + print (__file__+"/appendChild : newId : ",newId); + + return make_response(json.dumps( {'id':newId} )) + # return make_response(json.dumps( {'source':node, 'changeIsAccepted' : changeDone, 'message': message} )) + # Return a string along with an HTTP status code + # return "JSON received!", 200 + else: + # The request body wasn't JSON so return a 400 HTTP status code + return "Request was not JSON", 400 + #return make_response(jsonify({"message": "Request body must be JSON"}), 400) + +@app.route('/') +def index(): + +#PN decider de ce qu on appelle +# Lecture du cata +# Lecture du fichier + #eficasEditeur = eficasAppli.litFichierComm('../Codes/WebTest/web_tres_simple_avec_2Fact.comm') + #eficasAppli.litFichierComm('../WebTest/edg_REP1300_FULL_PN.comm') + + eficasEditeur = eficasAppli.openFile('../Codes/WebTest/web_tres_simple_avec_2Fact.comm') + print ('_____________________________________') + print (eficasAppli) + print ('dans index : eficasEditeur', eficasEditeur) + if not(eficasEditeur) : + return render_template('commandes_2.html', + titre='Pb a la lecture', + listeCommandes = [], + tree= None + ) + #myFancyTreeDico=session['eficasEditeur'].getDicoForFancy(session['eficasEditeur'].tree.racine) + session['eficasEditeur']=eficasEditeur.idUnique + eficasEditeur=eficasAppli.getEditorById(session['eficasEditeur']) + myFancyTreeDico=eficasEditeur.getDicoForFancy(eficasEditeur.tree.racine) + myFancyTreeJS=json.dumps([myFancyTreeDico],indent=4) #TODO : remove indent if not DEBUG + + #print("---- myFancyTreeDico ----") + #pprint(myFancyTreeDico) + #print("---- myFancyTreeJS ----") + #pprint( myFancyTreeJS) + + return render_template('commandes_2.html', + titre=code, + listeCommandes = eficasEditeur.getListeCommandes(), + tree=myFancyTreeJS, + # tree=tree4Fancy, + ) + # etape = str(escape(request.args.get("etape", ""))) + + +#TODO: +#from fileManagement import * + +def allowed_file(filename): + return '.' in filename and \ + filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS + + +def gen_file_name(filename): + """ + If file was exist already, rename it and return a new name + """ + + i = 1 + while os.path.exists(os.path.join(app.config['UPLOAD_FOLDER'], filename)): + name, extension = os.path.splitext(filename) + filename = '%s_%s%s' % (name, str(i), extension) + i += 1 + + return filename + + +def create_thumbnail(image): + try: + base_width = 80 + img = Image.open(os.path.join(app.config['UPLOAD_FOLDER'], image)) + w_percent = (base_width / float(img.size[0])) + h_size = int((float(img.size[1]) * float(w_percent))) + img = img.resize((base_width, h_size), PIL.Image.ANTIALIAS) + img.save(os.path.join(app.config['THUMBNAIL_FOLDER'], image)) + + return True + + except: + print(traceback.format_exc()) + return False + + +@app.route("/upload", methods=['GET', 'POST']) +def upload(): + if request.method == 'POST': + files = request.files['file'] + + if files: + filename = secure_filename(files.filename) + filename = gen_file_name(filename) + mime_type = files.content_type + + if not allowed_file(files.filename): + result = uploadfile(name=filename, type=mime_type, size=0, not_allowed_msg="File type not allowed") + + else: + # save file to disk + uploaded_file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename) + files.save(uploaded_file_path) + + # create thumbnail after saving + if mime_type.startswith('image'): + create_thumbnail(filename) + + # get file size after saving + size = os.path.getsize(uploaded_file_path) + + # return json for js call back + result = uploadfile(name=filename, type=mime_type, size=size) + + return simplejson.dumps({"files": [result.get_file()]}) + + if request.method == 'GET': + # get all file in ./data directory + files = [f for f in os.listdir(app.config['UPLOAD_FOLDER']) if os.path.isfile(os.path.join(app.config['UPLOAD_FOLDER'],f)) and f not in IGNORED_FILES ] + + file_display = [] + + for f in files: + size = os.path.getsize(os.path.join(app.config['UPLOAD_FOLDER'], f)) + file_saved = uploadfile(name=f, size=size) + file_display.append(file_saved.get_file()) + + return simplejson.dumps({"files": file_display}) + + return redirect(url_for('index')) + + + +@app.route("/delete/", methods=['DELETE']) +def delete(filename): + file_path = os.path.join(app.config['UPLOAD_FOLDER'], filename) + file_thumb_path = os.path.join(app.config['THUMBNAIL_FOLDER'], filename) + + if os.path.exists(file_path): + try: + os.remove(file_path) + + if os.path.exists(file_thumb_path): + os.remove(file_thumb_path) + + return simplejson.dumps({filename: 'True'}) + except: + return simplejson.dumps({filename: 'False'}) + + +# serve static files +@app.route("/thumbnail/", methods=['GET']) +def get_thumbnail(filename): + return send_from_directory(app.config['THUMBNAIL_FOLDER'], filename=filename) + + +@app.route("/data/", methods=['GET']) +def get_file(filename): + return send_from_directory(os.path.join(app.config['UPLOAD_FOLDER']), filename=filename) + + +# @app.route("/_upload", methods=['POST']) +# def _upload(): + +# # Parse the JSON into a Python dictionary +# req = request.get_json() +# # Print the dictionary +# uploadRequest=json.dumps([req],indent=4); #TODO : remove indent if not DEBUG +# pprint(uploadRequest); + +# return make_response(json.dumps( {'source':node, 'changeIsAccepted' : changeDone, 'message': message} )) +# # Return a string along with an HTTP status code +# # return "JSON received!", 200 +# else: +# print(request) +# files = request.files['files'] +# if files: +# result=catalogs.save(files) +# return make_response(json.dumps( {"files": ["coucou"]} )) +# # if request.method == 'POST' and 'files' in request.files: + + +# # The request body wasn't JSON so return a 400 HTTP status code +# return "Request was not JSON", 400 +# #return make_response(jsonify({"message": "Request body must be JSON"}), 400) + +# For example, you may want to override how request parameters are handled to preserve their order: +# from flask import Flask, Request +# from werkzeug.datastructures import ImmutableOrderedMultiDict +# class MyRequest(Request): +# """Request subclass to override request parameter storage""" +# parameter_storage_class = ImmutableOrderedMultiDict +# class MyFlask(Flask): +# """Flask subclass using the custom request class""" +# request_class = MyReq + +if __name__ == "__main__": + app.run(host="localhost", port=8321, debug=True) +