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
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é.
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.
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.
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)
# 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]
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
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()
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"}
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
dicoCataOrdonne=self.readercata.dicoCataOrdonne,
nom=jdcName,
repMat=self.maConfiguration.repMat,
+ editeur=self
)
self.modified = False
self.monJDCReader = monJDCReader
cata=self.readercata.cata,
dicoCataOrdonne=self.readercata.dicoCataOrdonne,
repMat=self.maConfiguration.repMat,
+ editeur=self
)
jdc.lang = self.appliEficas.langue
cata=self.readercata.cata,
dicoCataOrdonne=self.readercata.dicoCataOrdonne,
repMat=self.maConfiguration.repMat,
+ editeur=self
)
jaux.editor = self
jaux.analyse()
dicoCataOrdonne=self.readercata.dicoCataOrdonne,
jdc_pere=jaux,
repMat=self.maConfiguration.repMat,
+ editeur=self
)
J.editor = self
J.analyse()
#--------------------------
def getEditorById(self,id):
#--------------------------
- return self.editorManager.getEditorById(self,id)
+ return self.editorManager.getEditorById(id)
#----------------------------------
def setCurrentEditorById(self,id):
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ 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)
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from 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
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+"""
+from builtins import str
+from builtins import object
+import types, os, sys
+from copy import copy, deepcopy
+from uuid import uuid1
+
+# import du chargeur de composants
+from InterfaceGUI.Common.comploader import makeObjecttreeitem
+from Accas.accessor import CONNECTOR
+from Accas.extensions.eficas_translation import tr
+from Accas.extensions.eficas_exception import EficasException
+
+from reprlib import Repr
+
+myrepr = Repr()
+myrepr.maxstring = 100
+myrepr.maxother = 100
+
+
+class TreeItem(object):
+
+ """Abstract class representing tree items.
+
+ Methods should typically be overridden, otherwise a default action
+ is used.
+
+ """
+
+ # itemNode est une factory qui doit retourner un objet de la classe Node
+ # ou derive de cette classe.
+ # Le widget arbre utilisera cet objet comme noeud associe au tree item.
+ # Par defaut, utilise la classe Node de base
+ # La signature de la factory est la suivante :
+ # itemNode(treeOrNode,item,command,rmenu)
+ # ou treeOrNode est le noeud parent, item est l'item associe
+ # command est une fonction python appelee sur selection graphique
+ # du noeud et rmenu est une fonction python appelee sur click droit sur le noeud
+ itemNode = None
+
+ def __init__(self):
+ """Constructor. Do whatever you need to do."""
+
+ def getText(self):
+ """Return text string to display."""
+
+ def getLabelText(self):
+ """Return label text string to display in front of text (if any)."""
+
+ expandable = None
+
+ def _isExpandable(self):
+ if self.expandable is None:
+ self.expandable = self.isExpandable()
+ return self.expandable
+
+ def isExpandable(self):
+ """Return whether there are subitems."""
+ return 1
+
+ def _getSubList(self):
+ """Do not override! Called by TreeNode."""
+ if not self.isExpandable():
+ return []
+ sublist = self.getSubList()
+ if not sublist:
+ self.expandable = 0
+ return sublist
+
+ def IsEditable(self):
+ """Return whether the item's text may be edited."""
+ pass
+
+ def SetText(self, text):
+ """Change the item's text (if it is editable)."""
+ pass
+
+ def getIconName(self):
+ """Return name of icon to be displayed normally."""
+ pass
+
+ def getSelectedIconName(self):
+ """Return name of icon to be displayed when selected."""
+ pass
+
+ def getSubList(self):
+ """Return list of items forming sublist."""
+ pass
+
+ def onDoubleClick(self):
+ """Called on a double-click on the item."""
+ pass
+
+
+class Delegate(object):
+ def __init__(self, delegate=None):
+ self.object = delegate
+ self.__cache = {}
+
+ def setDelegate(self, delegate):
+ self.resetcache()
+ self.object = delegate
+
+ def getDelegate(self):
+ return self.object
+
+ def __getattr__(self, name):
+ attr = getattr(self.object, name) # May raise AttributeError
+ setattr(self, name, attr)
+ self.__cache[name] = attr
+ return attr
+
+ def resetcache(self):
+ for key in list(self.__cache.keys()):
+ try:
+ delattr(self, key)
+ except AttributeError:
+ pass
+ self.__cache.clear()
+
+ def cachereport(self):
+ keys = list(self.__cache.keys())
+ keys.sort()
+ # print keys
+
+
+class ObjectTreeItem(TreeItem, Delegate):
+ def __init__(self, appliEficas, labeltext, object, setFunction=None):
+ self.labeltext = labeltext
+ self.appliEficas = appliEficas
+ # L'objet delegue est stocke dans l'attribut object
+ # L'objet associe a l'item est stocke dans l'attribut _object
+ # Il peut etre obtenu par appel a la methode getObject
+ # Attention : le delegue peut etre different de l'objet associe (MCLIST)
+ # Dans le cas d'une MCListe de longueur 1, l'objet associe est la MCListe
+ # et l'objet delegue est le MCFACT (object = _object.data[0])
+ Delegate.__init__(self, object)
+ # On cache l'objet initial (pour destruction eventuelle
+ # ulterieure)
+ self._object = object
+ self.setFunction = setFunction
+ self.expandable = 1
+ self.sublist = []
+ self.init()
+
+
+ # La partie suivante ne sert que pour le Web
+ # on met le meme id au noeud et a l objet
+ # utile pour les MCList
+ if hasattr(object, "idUnique"):
+ self.idUnique = object.idUnique
+ else:
+ self.idUnique = uuid1().hex
+
+ if self._object.nature == "MCList" and len(self._object.data) == 1:
+ # pour les suppressions on met le meme id a l objet et a la liste
+ self._object.data[0].idUnique = self.idUnique
+ self._object.idUnique = self._object.data[0].idUnique
+ #if hasattr(self.appliEficas, "dicoIdNode"):
+ # self.appliEficas.dicoIdNode[self._object.data[0].idUnique] = self
+ #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
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ 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")
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Accas import PARAMETRE
+from 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
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# 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
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2024 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+import types
+from 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()
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
#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()
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
from InterfaceGUI.QT5 import compofact
from InterfaceGUI.QT5 import browser
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
from InterfaceGUI.QT5 import browser
from InterfaceGUI.QT5 import typeNode
from Accas.extensions.eficas_translation import tr
import traceback
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
from Accas.extensions.eficas_exception import EficasException
from InterfaceGUI.QT5 import compocomm
from InterfaceGUI.QT5 import typeNode
from Accas.extensions.eficas_translation import tr
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
import traceback
# 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
import traceback
# Modules Eficas
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
from Accas.extensions.eficas_translation import tr
from InterfaceGUI.QT5 import compooper
from InterfaceGUI.QT5 import browser
from InterfaceGUI.QT5 import typeNode
from Accas.extensions.eficas_translation import tr
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
from Accas.processing.P_OBJECT import ErrorObj
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
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):
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
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
from InterfaceGUI.QT5 import compooper
from InterfaceGUI.QT5 import browser
from InterfaceGUI.QT5 import typeNode
from 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:
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
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
# 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
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
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
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
# Notation scientifique
if test:
- from InterfaceGUI.common.politiquesValidation import Validation
+ from InterfaceGUI.Common.politiquesValidation import Validation
validation = Validation(self.node, self.editor)
validation.ajoutDsDictReelEtape()
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(
# 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
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
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
# 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
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*$")
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
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):
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):
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):
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):
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):
# 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
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):
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):
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):
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):
# 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
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)
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)
#----------------------------------------
#print ('__init__ JDCTree')
self.editor = editor
+ #print ('browser', self.editor)
self.plie = False
self.item = jdc_item
self.tree = self
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):
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=[]
self.children = []
self.buildChildren()
+ self.editor.dicoIdNode[item.idUnique] = item
self.item.connect("valid",self.onValid,())
self.item.connect("supp" ,self.onSupp,())
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):
#-----------------------------------
"""
#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)
#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'
#
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
from InterfaceGUI.Web import compofact
from InterfaceGUI.Web import browser
from InterfaceGUI.Web import browser
from InterfaceGUI.Web import typeNode
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
from Accas.extensions.eficas_translation import tr
# 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
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
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
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
# -*- 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
# 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
#
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
from InterfaceGUI.Web import compooper
from InterfaceGUI.Web import browser
from InterfaceGUI.Web import typeNode
import traceback
# Modules Eficas
-from InterfaceGUI.common import objecttreeitem
-from 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):
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
+
+
--- /dev/null
+ 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):
# 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
#--------------------------------------------------------------------------
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 """
#-----------------------------
+ @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)
+
def __init__(self, appliEficas):
#--------------------------------
super().__init__(appliEficas)
- self.dictSessions={}
+ self.dictEditors={}
+ self.dictSessions = {}
#---------------------------------------
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
+
+
from Accas.extensions.eficas_translation import tr
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
import traceback
# 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
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
import os
import tempfile
-from InterfaceGUI.common import objecttreeitem
+from InterfaceGUI.Common import objecttreeitem
from InterfaceGUI.cinqC import browser
class Node(browser.JDCNode ):
# 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
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- 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)
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
-"""
-from builtins import str
-from builtins import object
-import types, os, sys
-from copy import copy, deepcopy
-from uuid import uuid1
-
-# import du chargeur de composants
-from InterfaceGUI.common.comploader import makeObjecttreeitem
-from Accas.accessor import CONNECTOR
-from Accas.extensions.eficas_translation import tr
-from Accas.extensions.eficas_exception import EficasException
-
-from reprlib import Repr
-
-myrepr = Repr()
-myrepr.maxstring = 100
-myrepr.maxother = 100
-
-
-class TreeItem(object):
-
- """Abstract class representing tree items.
-
- Methods should typically be overridden, otherwise a default action
- is used.
-
- """
-
- # itemNode est une factory qui doit retourner un objet de la classe Node
- # ou derive de cette classe.
- # Le widget arbre utilisera cet objet comme noeud associe au tree item.
- # Par defaut, utilise la classe Node de base
- # La signature de la factory est la suivante :
- # itemNode(treeOrNode,item,command,rmenu)
- # ou treeOrNode est le noeud parent, item est l'item associe
- # command est une fonction python appelee sur selection graphique
- # du noeud et rmenu est une fonction python appelee sur click droit sur le noeud
- itemNode = None
-
- def __init__(self):
- """Constructor. Do whatever you need to do."""
-
- def getText(self):
- """Return text string to display."""
-
- def getLabelText(self):
- """Return label text string to display in front of text (if any)."""
-
- expandable = None
-
- def _isExpandable(self):
- if self.expandable is None:
- self.expandable = self.isExpandable()
- return self.expandable
-
- def isExpandable(self):
- """Return whether there are subitems."""
- return 1
-
- def _getSubList(self):
- """Do not override! Called by TreeNode."""
- if not self.isExpandable():
- return []
- sublist = self.getSubList()
- if not sublist:
- self.expandable = 0
- return sublist
-
- def IsEditable(self):
- """Return whether the item's text may be edited."""
- pass
-
- def SetText(self, text):
- """Change the item's text (if it is editable)."""
- pass
-
- def getIconName(self):
- """Return name of icon to be displayed normally."""
- pass
-
- def getSelectedIconName(self):
- """Return name of icon to be displayed when selected."""
- pass
-
- def getSubList(self):
- """Return list of items forming sublist."""
- pass
-
- def onDoubleClick(self):
- """Called on a double-click on the item."""
- pass
-
-
-class Delegate(object):
- def __init__(self, delegate=None):
- self.object = delegate
- self.__cache = {}
-
- def setDelegate(self, delegate):
- self.resetcache()
- self.object = delegate
-
- def getDelegate(self):
- return self.object
-
- def __getattr__(self, name):
- attr = getattr(self.object, name) # May raise AttributeError
- setattr(self, name, attr)
- self.__cache[name] = attr
- return attr
-
- def resetcache(self):
- for key in list(self.__cache.keys()):
- try:
- delattr(self, key)
- except AttributeError:
- pass
- self.__cache.clear()
-
- def cachereport(self):
- keys = list(self.__cache.keys())
- keys.sort()
- # print keys
-
-
-class ObjectTreeItem(TreeItem, Delegate):
- def __init__(self, appliEficas, labeltext, object, setFunction=None):
- self.labeltext = labeltext
- self.appliEficas = appliEficas
- # L'objet delegue est stocke dans l'attribut object
- # L'objet associe a l'item est stocke dans l'attribut _object
- # Il peut etre obtenu par appel a la methode getObject
- # Attention : le delegue peut etre different de l'objet associe (MCLIST)
- # Dans le cas d'une MCListe de longueur 1, l'objet associe est la MCListe
- # et l'objet delegue est le MCFACT (object = _object.data[0])
- Delegate.__init__(self, object)
- # On cache l'objet initial (pour destruction eventuelle
- # ulterieure)
- self._object = object
- self.setFunction = setFunction
- self.expandable = 1
- self.sublist = []
- self.init()
-
-
- # La partie suivante ne sert que pour le Web
- # on met le meme id au noeud et a l objet
- # utile pour les MCList
- if hasattr(object, "idUnique"):
- self.idUnique = object.idUnique
- else:
- self.idUnique = uuid1().hex
-
- if self._object.nature == "MCList" and len(self._object.data) == 1:
- # pour les suppressions on met le meme id a l objet et a la liste
- self._object.data[0].idUnique = self.idUnique
- self._object.idUnique = self._object.data[0].idUnique
- if hasattr(self.appliEficas, "dicoIdNode"):
- self.appliEficas.dicoIdNode[self._object.data[0].idUnique] = self
- self.idUnique = 0
- return
-
- self._object.idUnique = self.idUnique
- if hasattr(self.appliEficas, "dicoIdNode") and self.idUnique:
- self.appliEficas.dicoIdNode[self.idUnique] = self
-
- def init(self):
- return
-
- def getObject(self):
- return self._object
-
- def connect(self, channel, callable, args):
- """Connecte la fonction callable (avec arguments args) a l'item self sur le
- canal channel
- """
- # print self,channel,callable,args
- CONNECTOR.Connect(self._object, channel, callable, args)
- CONNECTOR.Connect(self.object, channel, callable, args)
-
- def copy(self):
- """
- Cree un item copie de self
- """
- object = self._object.copy()
- appliEficas = copy(self.appliEficas)
- labeltext = copy(self.labeltext)
- fonction = deepcopy(self.setFunction)
- item = makeObjecttreeitem(appliEficas, labeltext, object, fonction)
- return item
-
- def isActif(self):
- if hasattr(self.object, "actif"):
- return self.object.actif
- else:
- return 1
-
- def update(self, item):
- """
- Met a jour l'item courant a partir d'un autre item passe en argument
- Ne fait rien par defaut
- """
- pass
-
- def getLabelText(self):
- """Retourne 3 valeurs :
- - le texte a afficher dans le noeud representant l'item
- - la fonte dans laquelle afficher ce texte
- - la couleur du texte
- """
- # None --> fonte et couleur par defaut
- return tr(self.labeltext), None, None
-
- def getNature(self):
- """
- Retourne la nature de l'item et de l'objet
- """
- return self.object.nature
-
- def getRegles(self):
- """retourne les regles de l'objet pointe par self"""
- return self.object.getRegles()
-
- def getListeMcPresents(self):
- """Retourne la liste des mots-cles fils de l'objet pointe par self"""
- return self.object.listeMcPresents()
-
- def getVal(self):
- """Retourne le nom de la valeur de l'objet pointe par self dans le cas
- ou celle-ci est un objet (ASSD)"""
- return self.object.getVal()
-
- def get_definition(self):
- """
- Retourne l'objet definition de l'objet pointe par self
- """
- return self.object.definition
-
- def getListeMcOrdonnee(self, liste, dico):
- """retourne la liste ordonnee (suivant le catalogue) brute des mots-cles
- d'une entite composee dont le chemin complet est donne sous forme
- d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
- il faut encore rearranger cette liste (certains mots-cles deja
- presents ne doivent plus etre proposes, regles ...)"""
- return self.object.getListeMcOrdonnee(liste, dico)
-
- def getListeMcOrdonneeBrute(self, liste, dico):
- """
- retourne la liste ordonnee (suivant le catalogue) BRUTE des mots-cles
- d'une entite composee dont le chemin complet est donne sous forme
- d'une liste du type :ETAPE + MCFACT ou MCBLOC + ...
- """
- return self.object.getListeMcOrdonneeBrute(liste, dico)
-
- def getGenealogie(self):
- """
- Retourne la liste des noms des ascendants (noms de MCSIMP,MCFACT,MCBLOC ou ETAPE)
- de l'objet pointe par self
- """
- return self.object.getGenealogie()
-
- def getIndexChild(self, nom_fils):
- """
- Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
- Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
- le nouveau mot-cle
- """
- return self.object.getIndexChild(nom_fils)
-
- def getIndexChild_old(self, nom_fils):
- """
- Retourne l'index dans la liste des fils de self du nouveau fils de nom nom_fils
- Necessaire pour savoir a quelle position dans la liste des fils il faut ajouter
- le nouveau mot-cle
- """
- liste_noms_mc_ordonnee = self.getListeMcOrdonneeBrute(
- self.getGenealogie(), self.getJdc().dicoCataOrdonne
- )
- liste_noms_mc_presents = self.object.listeMcPresents()
- l = []
- for nom in liste_noms_mc_ordonnee:
- if nom in liste_noms_mc_presents or nom == nom_fils:
- l.append(nom)
- # l contient les anciens mots-cles + le nouveau dans l'ordre
- return l.index(nom_fils)
-
- def appendChild(self, name, pos=None):
- """
- Permet d'ajouter un item fils a self
- """
- if pos == "first":
- index = 0
- elif pos == "last":
- index = len(self.listeMcPresents())
- elif type(pos) == int:
- # la position est fixee
- index = pos
- # elif type(pos) == types.InstanceType:
- elif type(pos) == object:
- # pos est un item. Il faut inserer name apres pos
- index = self.getIndex(pos) + 1
- # elif type(name) == types.InstanceType:
- elif type(name) == object:
- index = self.getIndexChild(name.nom)
- else:
- index = self.getIndexChild(name)
- return self.addobject(name, index)
-
- def appendBrother(self, name, pos="after"):
- """
- Permet d'ajouter un frere a self
- par defaut on l'ajoute apres self
- """
- index = self._object.parent.getIndex(self.getObject())
- if pos == "before":
- index = index
- elif pos == "after":
- index = index + 1
- else:
- print((tr("%d n'est pas un index valide pour appendBrother", pos)))
- return
- return self.parent.addobject(name, index)
-
- def getCopieObjet(self):
- """Retourne une copie de l'objet pointe par self"""
- return self.object.copy()
-
- def getPosition(self):
- """Retourne la valeur de l'attribut position de l'objet pointe par self"""
- definition = self.get_definition()
- try:
- return getattr(definition, "position")
- except AttributeError:
- return "local"
-
- def getNom(self):
- """Retourne le nom de l'objet pointe par self"""
- return self.object.nom
-
- def getJdc(self):
- """Retourne le jdc auquel appartient l'objet pointe par self"""
- return self.object.jdc
-
- def getValeur(self):
- """Retourne la valeur de l'objet pointe par self"""
- return self.object.valeur
-
- def getCr(self):
- """Retourne le compte-rendu CR de self"""
- return self.object.report()
-
- def getObjetCommentarise(self):
- """
- Cette methode retourne un objet commentarise
- representatif de self.object
- --> a surcharger par les differents items
- """
- raise EficasException(
- "MESSAGE AU DEVELOPPEUR : il faut \
- surcharger la methode getObjetCommentarise() \
- pour la classe %s",
- self.__class__.__name__,
- )
-
- def isValid(self):
- """Retourne 1 si l'objet pointe par self est valide, 0 sinon"""
- return self.object.isValid()
-
- def isCopiable(self):
- """
- Retourne 1 si l'objet est copiable, 0 sinon
- Par defaut retourne 0
- """
- return 0
-
- def getMcPresents(self):
- """Retourne le dictionnaire des mots-cles presents de l'objet pointe par self"""
- return self.object.dictMcPresents()
-
- def verifConditionRegles(self, l_mc_presents):
- return self.object.verifConditionRegles(l_mc_presents)
-
- def getFr(self):
- """Retourne le fr de l'objet pointe par self"""
- try:
- return self.object.getFr()
- except:
- return ""
-
- def getDocu(self):
- """Retourne la cle de doc de l'objet pointe par self"""
- return self.object.getDocu()
-
- def setValeur(self, new_valeur):
- """Remplace la valeur de l'objet pointe par self par new_valeur"""
- return self.object.setValeur(new_valeur)
-
- def getText(self):
- return myrepr.repr(self.object)
-
- def getIconName(self):
- if not self.isExpandable():
- return "python"
-
- def IsEditable(self):
- return self.setFunction is not None
-
- def SetText(self, text):
- try:
- value = eval(text)
- self.setFunction(value)
- except:
- pass
-
- def isExpandable(self):
- return 1
-
- def getSubList(self):
- keys = dir(self.object)
- sublist = []
- for key in keys:
- try:
- value = getattr(self.object, key)
- except AttributeError:
- continue
- item = makeObjecttreeitem(
- self.appliEficas,
- str(key) + " =",
- value,
- lambda value, key=key, object=self.object: setattr(object, key, value),
- )
- sublist.append(item)
- return sublist
-
- # a piori inutile PN 06 11 17
- # def wait_fichier_init(self):
- """ Retourne 1 si l'object pointe par self attend un fichier d'initialisation
- (ex: macros POURSUITE et INCLUDE de Code_Aster), 0 SINON """
-
- # return self.object.definition.fichier_ini
-
- def makeObjecttreeitem(self, appliEficas, labeltext, object, setFunction=None):
- """
- Cette methode, globale pour les objets de type item, permet de construire et de retourner un objet
- de type item associe a l'object passe en argument.
- """
- return makeObjecttreeitem(appliEficas, labeltext, object, setFunction)
-
- # def __del__(self):
- # print "__del__",self
-
-
-class AtomicObjectTreeItem(ObjectTreeItem):
- def isExpandable(self):
- return 0
-
-
-class SequenceTreeItem(ObjectTreeItem):
- def isExpandable(self):
- return len(self._object) > 0
-
- def __len__(self):
- return len(self._object)
-
- def keys(self):
- return list(range(len(self._object)))
-
- def getIconName(self):
- if self._object.isValid():
- return "ast-green-los"
- elif self._object.isOblig():
- return "ast-red-los"
- else:
- return "ast-yel-los"
-
- def ajoutPossible(self):
- return self._object.ajoutPossible()
-
- def getIndex(self, child):
- """Retourne le numero de child dans la liste des enfants de self"""
- return self._object.getIndex(child.getObject())
-
- def getText(self):
- return " "
-
- def addItem(self, obj, pos):
- self._object.insert(pos, obj)
- item = self.makeObjecttreeitem(self.appliEficas, obj.nom + ":", obj)
- return item
-
- def suppItem(self, item):
- try:
- self._object.remove(item.getObject())
- # la liste peut etre retournee vide !
- message = "Mot-clef " + item.getObject().nom + " supprime"
- self.appliEficas.afficheMessages(message)
- return 1
- except:
- return 0
-
- def getSubList(self):
- isublist = iter(self.sublist)
- liste = self._object.data
- iliste = iter(liste)
- self.sublist = []
-
- while 1:
- old_obj = obj = None
- for item in isublist:
- old_obj = item.getObject()
- if old_obj in liste:
- break
-
- for obj in iliste:
- if obj is old_obj:
- break
-
- # nouvel objet : on cree un nouvel item
- def setFunction(value, object=obj):
- object = value
-
- it = self.makeObjecttreeitem(
- self.appliEficas, obj.nom + " : ", obj, setFunction
- )
- self.sublist.append(it)
- if old_obj is None and obj is None:
- break
- if old_obj is obj:
- self.sublist.append(item)
- return self.sublist
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-from 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
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2024 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-
-import types
-from 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()
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)
--- /dev/null
+# 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/<uuid:post_id>')
+@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/<string:filename>", 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/<string:filename>", methods=['GET'])
+def get_thumbnail(filename):
+ return send_from_directory(app.config['THUMBNAIL_FOLDER'], filename=filename)
+
+
+@app.route("/data/<string:filename>", 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)
+
