et de remplir le dictionnaire composants utilise par makeObjecttreeitem
"""
reper=os.path.dirname(__file__)
- repertoire=reper+"/../InterfaceQT4"
- package="InterfaceQT4"
+ if Ihm == 'QT' :
+ repertoire=reper+"/../InterfaceQT4"
+ package="InterfaceQT4"
+ elif Ihm == 'Web' :
+ repertoire=reper+"/../InterfaceWeb"
+ package="InterfaceWeb"
listfich=glob.glob(os.path.join(repertoire, "compo*.py"))
+
for fichier in listfich:
m= os.path.basename(fichier)[:-3]
module=__import__(package,globals(),locals(),[m])
# On cherche ensuite dans les composants (plugins)
try:
+ print (object.__class__)
+ print (composants)
itemtype= composants[object.__class__]
return itemtype
except:
Cette fonction permet de construire et de retourner un objet
de type item associe a l'object passe en argument.
"""
+ print (object)
c = gettreeitem(object)
return c(appliEficas,labeltext, object, setFunction)
ihmQTDir = os.path.join(repIni,"UiQT5")
editeurDir = os.path.join(repIni,"Editeur")
ihmDir = os.path.join(repIni,"InterfaceQT4")
+webDir = os.path.join(repIni,"InterfaceWeb")
if ihmDir not in sys.path : sys.path.append(ihmDir)
if ihmQTDir not in sys.path : sys.path.append(ihmQTDir)
if editeurDir not in sys.path : sys.path.append(editeurDir)
+if webDir not in sys.path : sys.path.append(webDir)
if sys.version_info[0] < 3:
print("Must be using Python 3")
except : fichier=None
monEficasSsIhm = getEficasSsIhm(code=options.code )
- from .editorSsIhm import JDCEditorSsIhm
- monEditeur=JDCEditorSsIhm(monEficasSsIhm,fichier)
+ from InterfaceWeb.editor import JDCWebEditor
+ monEditeur=JDCWebEditor(monEficasSsIhm,fichier)
print ('voici le JDCEditor', monEditeur)
def genereXML(code=None):
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+ from builtins import range
+except : pass
+
+import re
+import types,sys,os
+import traceback
+from . import typeNode
+
+
+
+from Extensions.i18n import tr
+#from .gereRegles import GereRegles
+
+class MainPage : pass
+#------------------------------------------
+#class JDCTree( MainPage,GereRegles ):
+class JDCTree( MainPage ):
+#------------------------------------------
+
+ def __init__( self, jdc_item, QWParent):
+ #----------------------------------------
+ self.editor = QWParent
+ self.plie=False
+ #if self.editor.widgetTree !=None :
+ # QTreeWidget.__init__(self, self.editor.widgetTree )
+ # self.editor.verticalLayout_2.addWidget(self)
+ # if self.editor.enteteQTree=='complet':
+ # self.headerItem().setText(0, "Commande ")
+ # self.headerItem().setText(1, "Concept/Valeur")
+ # else :
+ # self.headerItem().setText(0, "Commande ")
+ # self.setColumnWidth(0,200)
+ # self.setExpandsOnDoubleClick(False)
+ # self.setSelectionMode(3)
+ #else :
+ # QTreeWidget.__init__(self, None )
+ self.item = jdc_item
+ self.tree = self
+ self.appliEficas = self.editor.appliEficas
+ self.childrenComplete=[]
+ self.racine=self.item.itemNode(self,self.item)
+
+ self.itemCourant=None
+
+ #self.itemClicked.connect(self.handleOnItem)
+ #self.itemCollapsed.connect(self.handleCollapsedItem)
+ #self.itemExpanded.connect(self.handleExpandedItem)
+
+ self.node_selected = self.racine
+ self.inhibeExpand = True
+ #self.expandItem(self.racine)
+ #self.inhibeExpand = False
+ #if self.racine.children !=[] :
+ # if self.editor.maConfiguration.afficheCommandesPliees : self.racine.children[0].plieToutEtReaffiche()
+ # else : self.racine.children[0].deplieToutEtReaffiche()
+ # self.racine.children[0].fenetre.donnePremier()
+ #else :
+ # self.racine.affichePanneau()
+
+ # def handleContextMenu(self,item,coord):
+ #-------------------------------------
+ # def handleCollapsedItem(self,item):
+ #----------------------------------
+ # def handleExpandedItem(self,item):
+ #----------------------------------
+ # def handleOnItem(self,item,int):
+ #----------------------------------
+ # def choisitPremier(self,name):
+ #----------------------------
+# type de noeud
+COMMENT = "COMMENTAIRE"
+PARAMETERS = "PARAMETRE"
+
+class TreeItem : pass
+#------------------------------------------
+#class JDCNode(TreeItem,GereRegles):
+class JDCNode(TreeItem):
+#------------------------------------------
+ def __init__( self, treeParent, item, itemExpand=False, ancien=False ):
+ #----------------------------------------------------------------------
+ #print ("creation d'un noeud : ", item, " ",item.nom,"", treeParent, self)
+
+
+ self.item = item
+ self.vraiParent = treeParent
+ self.treeParent = treeParent
+ self.tree = self.treeParent.tree
+ self.editor = self.treeParent.editor
+ self.appliEficas = treeParent.appliEficas
+ self.JESUISOFF = 0
+ self.firstAffiche = True
+ self.childrenComplete=[]
+
+
+ #from . import compocomm
+ #from . import compoparam
+ #from . import composimp
+ #if (isinstance(self.item,compocomm.COMMTreeItem)) : name = tr("Commentaire")
+ #elif (isinstance(self.item,compoparam.PARAMTreeItem)) : name = tr(str(item.getLabelText()[0]))
+ #else : name = tr(item.getLabelText()[0])
+ if item.nom != tr(item.nom) : name = str(tr(item.nom)+" :")
+ #value = tr(str(item.getText() ) )
+
+
+ #if self.treeParent.plie==True :
+ # self.plie = True
+ # self.appartientAUnNoeudPlie = True
+ # if self.treeParent.item.isMCList() : self.appartientAUnNoeudPlie = self.treeParent.appartientAUnNoeudPlie
+ #else :
+ # self.plie = False
+ # self.appartientAUnNoeudPlie = False
+
+ if ancien and itemExpand : self.plie = False
+ if ancien and not itemExpand : self.plie = True
+ if (isinstance(self.item,composimp.SIMPTreeItem)) : self.plie=False
+
+ from . import compobloc
+ from . import compomclist
+
+ ajoutAuParentduNoeud=0
+ while (isinstance(self.treeParent,compobloc.Node) or ( isinstance(self.treeParent,compomclist.Node) and self.treeParent.item.isMCList())) :
+ self.treeParent.childrenComplete.append(self)
+ self.treeParent=self.treeParent.vraiParent
+ self.treeParent.childrenComplete.append(self)
+
+
+ #if (isinstance(self,compobloc.Node) or (isinstance(self,compomclist.Node) and self.item.isMCList()) or ( hasattr(self.item.parent,'inhibeValidator') and isinstance(self,compomclist.Node) and self.item.parent.inhibeValidator)) :
+ # Le dernier or ne sert que lorsqu'on est en train de creer une liste par les validator
+ # QTreeWidgetItem.__init__(self,None,mesColonnes)
+ #else :
+ # QTreeWidgetItem.__init__(self,self.treeParent,mesColonnes)
+
+ #self.setToolTip(0,self.item.getFr())
+ #self.setToolTip(1,self.item.getFr())
+ #repIcon=self.appliEficas.repIcon
+
+ #couleur=self.item.getIconName()
+ #monIcone = QIcon(repIcon+"/" + couleur + ".png")
+
+ #self.setIcon(0,monIcone)
+
+ self.children = []
+ self.buildChildren()
+ self.menu=None
+ self.existeMenu=1
+
+ #self.item.connect("valid",self.onValid,())
+ #self.item.connect("supp" ,self.onSupp,())
+ #self.item.connect("add" ,self.onAdd,())
+ #self.item.connect("redessine" ,self.onRedessine,())
+
+ self.state=""
+ self.fenetre=None
+ try :
+ if self.item.getObject().isBLOC() :
+ self.setExpanded(True)
+ self.plie=False
+ except :
+ pass
+
+
+ def buildChildren(self,posInsertion=10000):
+ #------------------------------------------
+ """ Construit la liste des enfants de self """
+ """ Se charge de remettre les noeuds Expanded dans le meme etat """
+ #print ("*********** buildChildren ",self,self.item, self.item.nom)
+ #print (poum)
+
+ self.listeItemExpanded=[]
+ self.listeItemPlie=[]
+
+ for enfant in self.childrenComplete :
+ if enfant.plie : self.listeItemPlie.append(enfant.item)
+ else : self.listeItemExpanded.append(enfant.item)
+
+ for enfant in self.childrenComplete :
+ parent = enfant.treeParent
+ parent.removeChild(enfant)
+ enfant.JESUISOFF=1
+
+
+ self.children = []
+ self.childrenComplete = []
+ sublist = self.item._getSubList()
+ ind=0
+
+ for item in sublist :
+ itemExpand=False
+ ancien=False
+ if item in self.listeItemExpanded : itemExpand=True; ancien=True
+ if item in self.listeItemPlie : itemExpand=False; ancien=True
+ nouvelItem=item.itemNode(self,item,itemExpand,ancien)
+ self.children.append(nouvelItem)
+
+ #print ("fin *********** buildChildren ",self,self.item, self.item.nom, self.children)
+
+
+ def chercheNoeudCorrespondant(self,objSimp):
+ #-------------------------------------------
+ sublist = self.item._getSubList()
+ for node in self.childrenComplete:
+ if node.item.object==objSimp : return node
+ return None
+ #def afficheCeNiveau(self):
+ #-------------------------
+ #def getPanelModifie(self):
+ #-------------------------
+ #def affichePanneau(self) :
+ #-------------------------
+ #def createPopUpMenu(self):
+ #-------------------------
+ #def commentIt(self):
+ #-------------------------
+ #def unCommentIt(self):
+ #-------------------------
+ #def addComment( self, after=True ):
+ #-----------------------------------
+ #def addParameters( self, after=True ):
+ #-------------------------------------
+ #def select( self ):
+ #------------------
+ #------------------------------------------------------------------
+ # Methodes de creation et destruction de noeuds
+ #------------------------------------------------------------------
+ #def appendBrother(self,name,pos='after',plier=False):
+ #----------------------------------------------------
+ #def verifiePosition(self,name,pos,aLaRacine=False):
+ #----------------------------------------------------
+ #def appendChild(self,name,pos=None,plier=False):
+ #------------------------------------------------
+ #def deplace(self):
+ #-----------------
+ #def delete(self):
+ #----------------
+ #def deleteMultiple(self,liste=()):
+ #--------------------------------
+ #def onValid(self):
+ #-----------------
+ #def onAdd(self,object):
+ #----------------------
+ #def onSupp(self,object):
+ #-----------------------
+ #def onRedessine(self):
+ #---------------------
+ # self.affichePanneau()
+
+ #def updateNodeValid(self):
+ #-----------------------
+ #def updateNodeLabel(self):
+ #-------------------------
+ #def updateNodeLabelInBlack(self):
+ #-------------------------------
+ #def updateNodeLabelInBlue(self):
+ #-------------------------------
+ #def updatePlusieursNodeLabelInBlue(self,liste):
+ #----------------------------------------------
+ #def updateNodeTexteInBlack(self):
+ #--------------------------------
+ #def updateNodeTexte(self):
+ #----------------------------
+ #def updateNodeTexteInBlue(self):
+ #--------------------------------
+ #def updateNodes(self):
+ #--------------------------------
+ #def updateValid(self) :
+ #----------------------
+ #def updateTexte(self):
+ #----------------------
+ #def forceRecalculChildren(self,niveau):
+ #--------------------------------------
+ #def doPaste(self,node_selected,pos='after'):
+ #--------------------------------------------
+ #def doPasteCommande(self,objet_a_copier,pos='after'):
+ #-----------------------------------------------------
+ #def doPastePremier(self,objet_a_copier):
+ #---------------------------------------
+ #def plieToutEtReafficheSaufItem(self, itemADeplier):
+ #---------------------------------------------------
+ #def plieToutEtReaffiche(self):
+ #-----------------------------
+ #def deplieToutEtReaffiche(self):
+ #-----------------------------
+ #def setPlie(self):
+ #-----------------
+ #def setPlieChildren(self):
+ #-----------------------------
+ #def setDeplie(self):
+ #-----------------------------
+ #def setDeplieChildren(self):
+ #-----------------------------
+ #def selectAvant(self):
+ #-----------------------------
+ #def selectApres(self):
+ #---------------------
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+
+from __future__ import absolute_import
+from Editeur import Objecttreeitem
+
+from . import compofact
+from . import browser
+from . import typeNode
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
+
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
+
+
+ def getPanelGroupe(self,parentQt,commande):
+ maDefinition=self.item.get_definition()
+ monObjet=self.item.object
+ monNom=self.item.nom
+ maCommande=commande
+ if hasattr(parentQt,'niveau'): self.niveau=parentQt.niveau+1
+ else : self.niveau=1
+ #from .monWidgetBloc import MonWidgetBloc
+ #widget=MonWidgetBloc(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
+
+
+class BLOCTreeItem(compofact.FACTTreeItem):
+ itemNode=Node
+
+ def isCopiable(self):
+ return 0
+
+
+import Accas
+treeitem = BLOCTreeItem
+objet = Accas.MCBLOC
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from __future__ import absolute_import
+from . import browser
+from . import typeNode
+from Extensions.i18n import tr
+from Editeur import Objecttreeitem
+
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNodePartiel):
+
+ def getPanelGroupe(self,parentQt,commande):
+ # ----------------------------------------
+ maDefinition=self.item.get_definition()
+ monObjet=self.item.object
+ monNom=self.item.nom
+ maCommande=commande
+ if hasattr(parentQt,'niveau'): self.niveau=parentQt.niveau+1
+ else : self.niveau=1
+ #if hasattr(self,'plie') and self.plie==True :
+ # from InterfaceQT4.monWidgetFactPlie import MonWidgetFactPlie
+ # widget=MonWidgetFactPlie(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
+ #elif self.editor.maConfiguration.afficheFirstPlies and self.firstAffiche:
+ # self.firstAffiche = False
+ # self.setPlie()
+ # from InterfaceQT4.monWidgetFactPlie import MonWidgetFactPlie
+ # widget=MonWidgetFactPlie(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
+ #else:
+ # from InterfaceQT4.monWidgetFact import MonWidgetFact
+ # widget=MonWidgetFact(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
+ #return widget
+
+
+ def createPopUpMenu(self):
+ # ------------------------
+ typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
+
+
+class FACTTreeItem(Objecttreeitem.ObjectTreeItem):
+ itemNode=Node
+
+ def isExpandable(self):
+ # ----------------------
+ return 1
+
+ def getText(self):
+ # ----------------
+ return ''
+
+ def getLabelText(self):
+ # ----------------------
+ """ Retourne 3 valeurs :
+ - le texte à afficher dans le noeud representant l'item
+ - la fonte dans laquelle afficher ce texte
+ - la couleur du texte
+ """
+ # None --> fonte et couleur par defaut
+ if not(hasattr(self.object,'getLabelText')): return self.object.nom,None,None
+ return self.object.getLabelText(),None,None
+
+ def isValid(self):
+ # ----------------
+ return self.object.isValid()
+
+ def isCopiable(self):
+ # ----------------
+ return 1
+
+ def getIconName(self):
+ # ----------------
+ if self.object.isValid() : return "ast-green-los"
+ elif self.object.isOblig(): return "ast-red-los"
+ else : return "ast-yel-los"
+
+
+ def getSubList(self):
+ # ----------------
+ """
+ Reactualise la liste des items fils stockes dans self.sublist
+ """
+ liste=self.object.mcListe
+ sublist=[None]*len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj=item.getObject()
+ if old_obj in liste:
+ pos=liste.index(old_obj)
+ sublist[pos]=item
+ else:
+ pass # objets supprimes ignores
+ # ajout des items lies aux nouveaux objets
+ pos=0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ def setFunction(value, object=obj):
+ object.setval(value)
+ item = self.makeObjecttreeitem(self.appliEficas, obj.nom + " : ", obj, setFunction)
+ sublist[pos]=item
+ pos=pos+1
+
+ self.sublist=sublist
+ return self.sublist
+
+ def addItem(self,name,pos):
+ objet = self.object.addEntite(name,pos)
+ return objet
+
+ def suppItem(self,item) :
+ """
+ Cette methode a pour fonction de supprimer l'item passee en argument
+ des fils de l'item FACT qui est son pere
+ - item = item du MOCLE a supprimer du MOCLE pere
+ - item.getObject() = MCSIMP ou MCBLOC
+ """
+ itemobject=item.getObject()
+ if itemobject.isOblig() :
+ return (0, tr('Impossible de supprimer un mot-cle obligatoire '))
+
+ if self.object.suppEntite(itemobject):
+ message = tr("Mot-cle %s supprime")+ itemobject.nom
+ return (1, message)
+ else:
+ return (0,tr('Pb interne : impossible de supprimer ce mot-cle'))
+
+import Accas
+objet = Accas.MCFACT
+treeitem = FACTTreeItem
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from __future__ import absolute_import
+from Editeur import Objecttreeitem
+from . import browser
+from . import typeNode
+from Extensions.i18n import tr
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuRacine):
+
+ def getPanel(self):
+ from .monChoixCommande import MonChoixCommande
+ return MonChoixCommande(self,self.item, self.editor)
+
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuRacine.createPopUpMenu(self)
+
+ def addParameters(self,apres):
+ param=self.appendChild("PARAMETRE",pos=0)
+ return param
+
+
+
+class JDCTreeItem(Objecttreeitem.ObjectTreeItem):
+ itemNode=Node
+
+ def isExpandable(self):
+ return 1
+
+ def getText(self):
+ return " "
+
+ def getLabelText(self):
+ # None --> fonte et couleur par defaut
+ return tr(self.object.nom),None,None
+
+ def getJdc(self):
+ """
+ Retourne l'objet pointe par self
+ """
+ return self.object
+
+ def getIconName(self):
+ if self.object.isValid():
+ return "ast-green-square"
+ else:
+ return "ast-red-square"
+
+ #def keys(self):
+ # if self.object.etapes_niveaux != []:
+ # return range(len(self.object.etapes_niveaux))
+ # else:
+ # return range(len(self.object.etapes))
+
+ def addItem(self,name,pos):
+ cmd = self._object.addEntite(name,pos)
+ return cmd
+
+ def suppItem(self,item) :
+ # item = item de l'ETAPE a supprimer du JDC
+ # item.getObject() = ETAPE ou COMMENTAIRE
+ # self.object = JDC
+
+ itemobject=item.getObject()
+ if self.object.suppEntite(itemobject):
+ if itemobject.nature == "COMMENTAIRE" :
+ message = tr("Commentaire supprime")
+ else :
+ message = tr("Commande %s supprimee",itemobject.nom)
+ return 1,message
+ else:
+ message=tr("Pb interne : impossible de supprimer cet objet")
+ return 0,message
+
+ def getSubList(self):
+ """
+ Retourne la liste des items fils de l'item jdc.
+ Cette liste est conservee et mise a jour a chaque appel
+ """
+ if self.object.etapes_niveaux != []:
+ liste = self.object.etapes_niveaux
+ else:
+ liste = self.object.etapes
+ sublist=[None]*len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj=item.getObject()
+ if old_obj in liste:
+ pos=liste.index(old_obj)
+ sublist[pos]=item
+ else:
+ pass # objets supprimes ignores
+ # ajout des items lies aux nouveaux objets
+ pos=0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ item = self.makeObjecttreeitem(self.appliEficas, obj.nom + " : ", obj)
+ sublist[pos]=item
+ pos=pos+1
+
+ self.sublist=sublist
+ return self.sublist
+
+ def getLNomsEtapes(self):
+ """ Retourne la liste des noms des etapes de self.object"""
+ return self.object.getLNomsEtapes()
+
+ def getListeCmd(self):
+ listeCmd = self.object.niveau.definition.getListeCmd()
+ return listeCmd
+
+import Accas
+treeitem =JDCTreeItem
+objet = Accas.JDC
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+
+from __future__ import absolute_import
+import types
+import traceback
+
+from . import compofact
+from . import browser
+from . import typeNode
+from Extensions.i18n import tr
+
+from Editeur import Objecttreeitem
+from Noyau.N_OBJECT import ErrorObj
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
+
+ def getPanelGroupe(self,parentQt,commande):
+ maDefinition=self.item.get_definition()
+ monObjet=self.item.object
+ monNom=self.item.nom
+ maCommande=commande
+ if hasattr(parentQt,'niveau'): self.niveau=parentQt.niveau+1
+ else : self.niveau=1
+ # attention si l objet est une mclist on utilise bloc
+ #if not (monObjet.isMCList()) :
+ # if hasattr(self,'plie') and self.plie==True :
+ # from InterfaceQT4.monWidgetFactPlie import MonWidgetFactPlie
+ # widget=MonWidgetFactPlie(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
+ # elif self.editor.maConfiguration.afficheFirstPlies and self.firstAffiche:
+ # self.firstAffiche = False
+ # self.setPlie()
+ # from InterfaceQT4.monWidgetFactPlie import MonWidgetFactPlie
+ # widget=MonWidgetFactPlie(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
+ # else:
+ # from InterfaceQT4.monWidgetFact import MonWidgetFact
+ # widget=MonWidgetFact(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
+ #else :
+ # from InterfaceQT4.monWidgetBloc import MonWidgetBloc
+ # widget=MonWidgetBloc(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
+ #return widget
+
+
+
+ def doPaste(self,node_selected,pos):
+ objet_a_copier = self.item.getCopieObjet()
+ # before est un effet de bord heureux sur l index
+ child=self.appendBrother(objet_a_copier,'before')
+ if self.editor.fenetreCentraleAffichee : self.editor.fenetreCentraleAffichee.node.affichePanneau()
+ self.update_NodeLabelInBlack()
+ self.parent().buildChildren()
+ return child
+
+
+
+class MCListTreeItem(Objecttreeitem.SequenceTreeItem,compofact.FACTTreeItem):
+ """ La classe MCListTreeItem joue le role d'un adaptateur pour les objets
+ du noyau Accas instances de la classe MCLIST.
+ Elle adapte ces objets pour leur permettre d'etre integres en tant que
+ noeuds dans un arbre graphique (voir treewidget.py et ObjectTreeItem.py).
+ Cette classe delegue les appels de methode et les acces
+ aux attributs a l'objet du noyau soit manuellement soit
+ automatiquement (voir classe Delegate et attribut object).
+ """
+ itemNode=Node
+
+ def init(self):
+ # Si l'objet Accas (MCList) a moins d'un mot cle facteur
+ # on utilise directement ce mot cle facteur comme delegue
+ self.updateDelegate()
+
+ def updateDelegate(self):
+ if len(self._object) > 1:
+ self.setDelegate(self._object)
+ else:
+ self.setDelegate(self._object.data[0])
+
+ def panel(self,jdcdisplay,pane,node):
+ """ Retourne une instance de l'objet panneau associe a l'item (self)
+ Si la liste ne contient qu'un mot cle facteur, on utilise le panneau
+ FACTPanel.
+ Si la liste est plus longue on utilise le panneau MCLISTPanel.
+ """
+ if len(self._object) > 1:
+ return MCLISTPanel(jdcdisplay,pane,node)
+ elif isinstance(self._object.data[0],ErrorObj):
+ return compoerror.ERRORPanel(jdcdisplay,pane,node)
+ else:
+ return compofact.FACTPanel(jdcdisplay,pane,node)
+
+ def isExpandable(self):
+ if len(self._object) > 1:
+ return Objecttreeitem.SequenceTreeItem.isExpandable(self)
+ else:
+ return compofact.FACTTreeItem.isExpandable(self)
+
+ def getSubList(self):
+ self.updateDelegate()
+ if len(self._object) <= 1:
+ self._object.data[0].alt_parent=self._object
+ return compofact.FACTTreeItem.getSubList(self)
+
+ liste=self._object.data
+ sublist=[None]*len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj=item.getObject()
+ if old_obj in liste:
+ pos=liste.index(old_obj)
+ sublist[pos]=item
+ else:
+ pass # objets supprimes ignores
+ # ajout des items lies aux nouveaux objets
+ pos=0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ def setFunction(value, object=obj):
+ object=value
+ item = self.makeObjecttreeitem(self.appliEficas, obj.nom + " : ", obj, setFunction)
+ sublist[pos]=item
+ #Attention : on ajoute une information supplementaire pour l'actualisation de
+ # la validite. L'attribut parent d'un MCFACT pointe sur le parent de la MCLISTE
+ # et pas sur la MCLISTE elle meme ce qui rompt la chaine de remontee des
+ # informations de validite. alt_parent permet de remedier a ce defaut.
+ obj.alt_parent=self._object
+ pos=pos+1
+
+ self.sublist=sublist
+ return self.sublist
+
+ def getIconName(self):
+ if self._object.isValid():
+ return "ast-green-los"
+ elif self._object.isOblig():
+ return "ast-red-los"
+ else:
+ return "ast-yel-los"
+
+ def getDocu(self):
+ """ Retourne la clef de doc de l'objet pointe par self """
+ return self.object.getDocu()
+
+ def isCopiable(self):
+ if len(self._object) > 1:
+ return Objecttreeitem.SequenceTreeItem.isCopiable(self)
+ else:
+ return compofact.FACTTreeItem.isCopiable(self)
+
+ def isMCFact(self):
+ """
+ Retourne 1 si l'objet pointe par self est un MCFact, 0 sinon
+ """
+ return len(self._object) <= 1
+
+ def isMCList(self):
+ """
+ Retourne 1 si l'objet pointe par self est une MCList, 0 sinon
+ """
+ return len(self._object) > 1
+
+ def getCopieObjet(self):
+ return self._object.data[0].copy()
+
+ def addItem(self,obj,pos):
+ #print "compomclist.addItem",obj,pos
+ if len(self._object) <= 1:
+ return compofact.FACTTreeItem.addItem(self,obj,pos)
+
+ o= self.object.addEntite(obj,pos)
+ return o
+
+ def suppItem(self,item):
+ """
+ Retire un objet MCFACT de la MCList (self.object)
+ """
+ #print "compomclist.suppItem",item
+ obj=item.getObject()
+ if len(self._object) <= 1:
+ return compofact.FACTTreeItem.suppItem(self,item)
+
+ if self.object.suppEntite(obj):
+ if len(self._object) == 1: self.updateDelegate()
+ message = "Mot-clef " + obj.nom + " supprime"
+ return (1,message)
+ else:
+ return (0,tr('Impossible de supprimer ce mot-clef'))
+
+
+import Accas
+objet = Accas.MCList
+
+def treeitem(appliEficas,labeltext,object,setFunction):
+ """ Factory qui produit un objet treeitem adapte a un objet
+ Accas.MCList (attribut objet de ce module)
+ """
+ return MCListTreeItem(appliEficas,labeltext,object,setFunction)
--- /dev/null
+#-*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+import os
+import tempfile
+
+from Extensions.i18n import tr
+from Extensions.eficas_exception import EficasException
+from Editeur import Objecttreeitem
+from . import browser
+from . import typeNode
+
+class Node(browser.JDCNode, typeNode.PopUpMenuNode):
+
+
+ def select(self):
+ browser.JDCNode.select(self)
+ self.treeParent.tree.openPersistentEditor(self,1)
+ self.monWidgetNom=self.treeParent.tree.itemWidget(self,1)
+ self.monWidgetNom.returnPressed.connect(self.nomme)
+ if self.item.getIconName() == "ast-red-square" : self.monWidgetNom.setDisabled(True)
+ #else : self.monWidgetNom.setFocus() ;self.monWidgetNom.setDisabled(False)
+
+ def nomme(self):
+ nom=str(self.monWidgetNom.text())
+ self.editor.initModif()
+ test,mess = self.item.nommeSd(nom)
+ if (test== 0):
+ self.editor.afficheInfos(mess,'red')
+ old=self.item.getText()
+ self.monWidgetNom.setText(old)
+ else :
+ self.editor.afficheCommentaire(tr("Nommage du concept effectue"))
+ self.onValid()
+ try :
+ self.fenetre.LENom.setText(nom)
+ except :
+ pass
+
+
+ def getPanel(self):
+ from .monWidgetCommande import MonWidgetCommande
+ return MonWidgetCommande(self,self.editor,self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNode.createPopUpMenu(self)
+
+# def view3D(self) :
+# from Editeur import TroisDPal
+# troisD=TroisDPal.TroisDPilote(self.item,self.editor.appliEficas)
+# troisD.envoievisu()
+
+
+class EtapeTreeItem(Objecttreeitem.ObjectTreeItem):
+ """ La classe EtapeTreeItem est un adaptateur des objets ETAPE du noyau
+ Accas. Elle leur permet d'etre affichés comme des noeuds
+ d'un arbre graphique.
+ Cette classe a entre autres deux attributs importants :
+ - _object qui est un pointeur vers l'objet du noyau
+ - object qui pointe vers l'objet auquel sont délégués les
+ appels de méthode et les acces aux attributs
+ Dans le cas d'une ETAPE, _object et object pointent vers le
+ meme objet.
+ """
+ itemNode=Node
+
+ def isExpandable(self):
+ return 1
+
+ def getIconName(self):
+ """
+ Retourne le nom de l'icone a afficher dans l'arbre
+ Ce nom depend de la validite de l'objet
+ """
+ if not self.object.isActif():
+ return "ast-white-square"
+ elif self.object.isValid():
+ return "ast-green-square"
+ else:
+ valid=self.validChild()
+ valid= valid * self.validRegles("non")
+ if self.reste_val != {} : valid=0
+ if valid==0 :
+ return "ast-red-square"
+ else :
+ try :
+ # on traite ici le cas d include materiau
+ # print self.object.definition.nom
+ if self.object.fichier_ini != self.object.nom_mater :
+ return "ast-red-square"
+ except :
+ pass
+ return "ast-yellow-square"
+
+ def getLabelText(self):
+ """ Retourne 3 valeurs :
+ - le texte a afficher dans le noeud représentant l'item
+ - la fonte dans laquelle afficher ce texte
+ - la couleur du texte
+ """
+ return self.labeltext,None,None
+ #if self.object.isActif():
+ # None --> fonte et couleur par défaut
+ # return self.labeltext,None,None
+ #else:
+ # return self.labeltext, None, None #CS_pbruno todo
+
+ #def get_objet(self,name) :
+ # for v in self.object.mcListe:
+ # if v.nom == name : return v
+ # return None
+
+ # def getType_sd_prod(self):
+ # """
+ # Retourne le nom du type du concept résultat de l'étape
+ # """
+ # sd_prod=self.object.getType_produit()
+ # if sd_prod:
+ # return sd_prod.__name__
+ # else:
+ # return ""
+
+ def addItem(self,name,pos):
+ mcent = self._object.addEntite(name,pos)
+ return mcent
+
+
+ def suppItem(self,item) :
+ # item : item du MOCLE de l'ETAPE a supprimer
+ # item.getObject() = MCSIMP, MCFACT, MCBLOC ou MCList
+ itemobject=item.getObject()
+ if itemobject.isOblig() :
+ return (0,tr('Impossible de supprimer un mot-clef obligatoire '))
+ if self.object.suppEntite(itemobject):
+ message = tr("Mot-clef %s supprime " , itemobject.nom)
+ return (1,message)
+ else :
+ return (0,tr('Pb interne : impossible de supprimer ce mot-clef'))
+
+ def getText(self):
+ try:
+ return self.object.getSdname()
+ except:
+ return ''
+
+ # PNPN ????
+ #def keys(self):
+ # keys=self.object.mc_dict
+ # return keys
+
+ def getSubList(self):
+ """
+ Reactualise la liste des items fils stockes dans self.sublist
+ """
+ if self.isActif():
+ liste=self.object.mcListe
+ else:
+ liste=[]
+
+ sublist=[None]*len(liste)
+ # suppression des items lies aux objets disparus
+ for item in self.sublist:
+ old_obj=item.getObject()
+ if old_obj in liste:
+ pos=liste.index(old_obj)
+ sublist[pos]=item
+ else:
+ pass # objets supprimes ignores
+
+ # ajout des items lies aux nouveaux objets
+ pos=0
+ for obj in liste:
+ if sublist[pos] is None:
+ # nouvel objet : on cree un nouvel item
+ def setFunction(value, object=obj):
+ object.setval(value)
+ item = self.makeObjecttreeitem(self.appliEficas, obj.nom + " : ", obj, setFunction)
+ sublist[pos]=item
+ pos=pos+1
+
+ self.sublist=sublist
+ return self.sublist
+
+ def isValid(self):
+ return self.object.isValid()
+
+ def isCopiable(self):
+ """
+ Retourne 1 si l'objet est copiable, 0 sinon
+ """
+ return 1
+
+ def updateDeplace(self,item):
+ if item.sd and item.sd.nom:
+ self.object.sd=item.sd
+ self.object.sd.nom=item.sd.nom
+
+ def update(self,item):
+ if item.sd and item.sd.nom:
+ self.nommeSd(item.sd.nom)
+
+ def nommeSd(self,nom):
+ """ Lance la méthode de nommage de la SD """
+ oldnom=""
+ if self.object.sd != None :
+ oldnom=self.object.sd.nom
+ test,mess= self.object.nommeSd(nom)
+ if test:self.object.parent.resetContext()
+ if (test and oldnom in self.appliEficas.dict_reels ):
+ self.appliEficas.dict_reels[nom]=self.appliEficas.dict_reels[oldnom]
+ return test,mess
+
+ def isReentrant(self):
+ return self.object.isReentrant()
+
+ def getNomsSdOperReentrant(self):
+ return self.object.getNomsSdOperReentrant()
+
+ def getObjetCommentarise(self):
+ """
+ Cette méthode retourne un objet commentarisé
+ représentatif de self.object
+ """
+ # Format de fichier utilisé
+ format=self.appliEficas.formatFichierIn
+ return self.object.getObjetCommentarise(format)
+
+ def getObjetCommentarise_BAK(self):
+ """
+ Cette méthode retourne un objet commentarisé
+ représentatif de self.object
+ """
+ import generator,Accas
+ # Format de fichier utilisé
+ format=self.appliEficas.format_fichier
+ g=generator.plugins[format]()
+ texte_commande = g.gener(self.object,format='beautifie')
+ # Il faut enlever la premiere ligne vide de texte_commande que
+ # rajoute le generator
+ rebut,texte_commande = texte_commande.split('\n',1)
+ # on construit l'objet COMMANDE_COMM repésentatif de self mais non
+ # enregistré dans le jdc
+ commande_comment = Accas.COMMANDE_COMM(texte=texte_commande,reg='non',
+ parent=self.object.parent)
+ commande_comment.niveau = self.object.niveau
+ commande_comment.jdc = commande_comment.parent = self.object.jdc
+
+ pos=self.object.parent.etapes.index(self.object)
+ parent=self.object.parent
+ self.object.parent.suppEntite(self.object)
+ parent.addEntite(commande_comment,pos)
+
+ return commande_comment
+
+
+import Accas
+treeitem = EtapeTreeItem
+objet = Accas.ETAPE
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module contient les classes permettant de definir les objets graphiques
+ representant un objet de type PARAMETRE, cad le panneau et l'item de l'arbre
+ d'EFICAS
+"""
+from __future__ import absolute_import
+try :
+ from builtins import str
+except : pass
+
+
+# import modules Python
+import types
+from Extensions.i18n import tr
+
+# import modules EFICAS
+from Editeur import Objecttreeitem
+from . import browser
+from . import typeNode
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNodePartiel):
+ def getPanel(self):
+ """
+ """
+ from .monWidgetParam import MonWidgetParam
+ return MonWidgetParam(self, self.editor,self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNodePartiel.createPopUpMenu(self)
+ self.menu.removeAction(self.Documentation)
+
+ def doPaste(self,node_selected,pos='after'):
+ return None
+
+
+
+class PARAMTreeItem(Objecttreeitem.ObjectTreeItem):
+ """
+ Classe servant a definir l'item porte par le noeud de l'arbre d'EFICAS
+ qui represente le PARAMETRE
+ """
+ itemNode=Node
+
+ def init(self):
+ self.setFunction = self.setValeur
+
+# ---------------------------------------------------------------------------
+# API du PARAMETRE pour l'arbre
+# ---------------------------------------------------------------------------
+
+ def getIconName(self):
+ """
+ Retourne le nom de l'icone associee au noeud qui porte self,
+ dependant de la validite de l'objet
+ NB : un PARAMETRE est toujours valide ...
+ """
+ if self.isActif():
+ if self.isValid():
+ return "ast-green-square"
+ else:
+ return "ast-red-square"
+ else:
+ return "ast-white-square"
+
+ def getLabelText(self):
+ """ Retourne 3 valeurs :
+ - le texte a afficher dans le noeud representant l'item
+ - la fonte dans laquelle afficher ce texte
+ - la couleur du texte
+ """
+ return tr('PARAMETRE'),None,None
+
+ def getText(self):
+ """
+ Retourne le texte a afficher apres le nom de la commande (ici apres 'parametre')
+ Ce texte est tronque a 25 caracteres
+ """
+ texte=self.object.nom+"="+str(self.object.valeur)
+ if type(self.object.valeur) == list :
+ texte=self.nom+' = ['
+ for l in self.object.valeur :
+ texte=texte+str(l) +","
+ texte=texte[0:-1]+']'
+ texte = texte.split('\n')[0]
+ if len(texte) < 25 :
+ return texte
+ else :
+ return texte[0:24]+'...'
+
+ def getSubList(self):
+ """
+ Retourne la liste des fils de self
+ """
+ return []
+
+# ---------------------------------------------------------------------------
+# Methodes permettant la modification et la lecture des attributs
+# du parametre = API graphique du PARAMETRE pour Panel et EFICAS
+# ---------------------------------------------------------------------------
+
+ def getValeur(self):
+ """
+ Retourne la valeur de l'objet PARAMETRE cad son texte
+ """
+ if self.object.valeur is None: return ''
+ else: return self.object.valeur
+
+ def getNom(self):
+ """
+ Retourne le nom du parametre
+ """
+ return self.object.nom
+
+ def setValeur(self,new_valeur):
+ """
+ Affecte valeur a l'objet PARAMETRE
+ """
+ self.object.setValeur(new_valeur)
+
+ def setNom(self,new_nom):
+ """
+ Renomme le parametre
+ """
+ self.object.setNom(new_nom)
+ #self.object.setAttribut('nom',new_nom)
+
+ def getFr(self):
+ """
+ Retourne le fr associe au parametre, cad la bulle d'aide pour EFICAS
+ """
+ return tr("Definition d'un parametre")
+
+import Extensions.parametre
+treeitem =PARAMTreeItem
+objet = Extensions.parametre.PARAMETRE
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from Editeur import Objecttreeitem
+from . import compooper
+from . import browser
+from . import typeNode
+
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNode):
+
+ def getPanel(self):
+ #print "getPanel de compoproc"
+ from .monWidgetCommande import MonWidgetCommande
+ return MonWidgetCommande(self,self.editor,self.item.object)
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNode.createPopUpMenu(self)
+
+
+class ProcEtapeTreeItem(compooper.EtapeTreeItem):
+ itemNode=Node
+
+import Accas
+treeitem = ProcEtapeTreeItem
+objet = Accas.PROC_ETAPE
--- /dev/null
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+# Modules Python
+try :
+ from builtins import str
+except : pass
+
+import types,os
+
+from copy import copy,deepcopy
+import traceback
+
+# Modules Eficas
+from Editeur import Objecttreeitem
+from Noyau.N_CR import justifyText
+from Accas import SalomeEntry
+from Accas import ASSD
+from Accas import UserASSD
+from Accas import UserASSDMultiple
+from . import typeNode
+from . import browser
+
+class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
+
+
+ def getPanelGroupe(self,parentQt,maCommande):
+ print ('getPanelGroupe de composimp pour ',self,self.item.nom, )
+ maDefinition=self.item.get_definition()
+ monObjet=self.item.object
+ monNom=self.item.nom
+
+ # a gerer comme dans composimp
+ # Gestion des matrices
+ #if self.item.waitMatrice ():
+ # from InterfaceQT4.monWidgetMatrice import MonWidgetMatrice
+ # widget=MonWidgetMatrice(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ # self.widget=widget
+ # return widget
+
+ #print "____________________________", monNom, self.item.waitCo()
+ #print "____________________________", monNom, self.item.waitAssd()
+ # Gestion d'une seule valeur (eventuellement un tuple ou un complexe)
+ if maDefinition.into != [] and maDefinition.into != None:
+ if type(maDefinition.into) ==types.FunctionType : monInto=maDefinition.into()
+ else : monInto = maDefinition.into
+
+
+ #if maDefinition.max == 1 :
+
+ # if maDefinition.intoSug != [] and maDefinition.intoSug != None:
+ # from InterfaceQT4.monWidgetCBIntoSug import MonWidgetCBIntoSug
+ # widget=MonWidgetCBIntoSug(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ # elif maDefinition.into != [] and maDefinition.into != None:
+ # if maDefinition.fenetreIhm=='menuDeroulant' :
+ # from InterfaceQT4.monWidgetCB import MonWidgetCB
+ # widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ # elif len(monInto) < 4 :
+ # from InterfaceQT4.monWidgetRadioButton import MonWidgetRadioButton
+ # widget=MonWidgetRadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ # elif len(monInto) < 7 :
+ # from InterfaceQT4.monWidget4a6RadioButton import MonWidget4a6RadioButton
+ # widget=MonWidget4a6RadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ # else :
+ # from InterfaceQT4.monWidgetCB import MonWidgetCB
+ # widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+
+# # elif self.item.waitBool() :
+# from InterfaceQT4.monWidgetSimpBool import MonWidgetSimpBool
+# widget=MonWidgetSimpBool(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# elif self.item.waitFichier():
+# from InterfaceQT4.monWidgetSimpFichier import MonWidgetSimpFichier
+# widget=MonWidgetSimpFichier(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+#
+# # PNPNPN - a faire
+# elif self.item.waitDate():
+# from InterfaceQT4.monWidgetDate import MonWidgetDate
+# widget=MonWidgetDate(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# elif self.item.waitHeure():
+# from InterfaceQT4.monWidgetHeure import MonWidgetHeure
+# widget=MonWidgetHeure(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+#
+# elif self.item.waitTuple() :
+# num=self.item.object.definition.type[0].ntuple
+# nomDeLaClasse = 'MonWidgetSimpTuple'+str(num)
+# nomDuFichier = 'InterfaceQT4.monWidgetSimpTupleN'
+# try :
+# #if 1 :
+# _temp = __import__(nomDuFichier, globals(), locals(), [nomDeLaClasse], 0)
+# #print (_temp)
+# MonWidgetSimpTuple = getattr(_temp,nomDeLaClasse)
+# except :
+# print ("Pas de Tuple de longueur : ", num)
+# # print ("Prevenir la maintenance ")
+# widget=MonWidgetSimpTuple(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+#
+# elif self.item.waitComplex():
+# from InterfaceQT4.monWidgetSimpComplexe import MonWidgetSimpComplexe
+# widget=MonWidgetSimpComplexe(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+#
+# elif self.item.waitCo():
+# if len(self.item.getSdAvantDuBonType()) == 0 :
+# from InterfaceQT4.monWidgetUniqueSDCO import MonWidgetUniqueSDCO
+# widget=MonWidgetUniqueSDCO(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# from InterfaceQT4.monWidgetSDCOInto import MonWidgetSDCOInto
+# widget=MonWidgetSDCOInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# elif self.item.waitAssd():
+#
+# # PN - pour ne pas appeller trop souvent self.item.getSdAvantDuBonType()
+# if not (self.item.waitUserAssdOrAssdMultipleEnCreation()) : maListe=self.item.getSdAvantDuBonType()
+# if self.item.waitUserAssdOrAssdMultipleEnCreation() :
+# from InterfaceQT4.monWidgetCreeUserAssd import MonWidgetCreeUserAssd
+# widget=MonWidgetCreeUserAssd(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# #elif len(self.item.getSdAvantDuBonType()) == 0 :
+# elif len(maListe) == 0 :
+# from InterfaceQT4.monWidgetVide import MonWidgetVide
+# widget=MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# #elif len(self.item.getSdAvantDuBonType()) < 4 :
+# elif len(maListe) < 4 :
+# from InterfaceQT4.monWidgetRadioButton import MonWidgetRadioButtonSD
+# widget=MonWidgetRadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# #elif len(self.item.getSdAvantDuBonType()) < 7 :
+# elif len(maListe) < 7 :
+# from InterfaceQT4.monWidget4a6RadioButton import MonWidget4a6RadioButtonSD
+# widget=MonWidget4a6RadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# from InterfaceQT4.monWidgetCB import MonWidgetCBSD
+# widget=MonWidgetCBSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+#
+# elif self.item.waitSalome() and self.editor.salome:
+# from InterfaceQT4.monWidgetSimpSalome import MonWidgetSimpSalome
+# widget=MonWidgetSimpSalome(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+#
+# elif self.item.waitTxm():
+# from InterfaceQT4.monWidgetSimpTxt import MonWidgetSimpTxt
+# widget=MonWidgetSimpTxt(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# from InterfaceQT4.monWidgetSimpBase import MonWidgetSimpBase
+# widget=MonWidgetSimpBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+#
+# # Gestion des listes
+# else :
+# if maDefinition.intoSug != [] and maDefinition.intoSug != None:
+# if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
+# from InterfaceQT4.monWidgetIntoSug import MonWidgetIntoSug
+# widget=MonWidgetIntoSug(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# from InterfaceQT4.monWidgetPlusieursPlie import MonWidgetPlusieursPlie
+# widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# #if maDefinition.into != [] and maDefinition.into != None:
+# # Attention pas fini --> on attend une liste de ASSD avec ordre
+# elif self.item.waitAssd() and self.item.isListSansOrdreNiDoublon():
+# listeAAfficher = self.item.getSdAvantDuBonType()
+# if len(listeAAfficher) == 0:
+# from InterfaceQT4.monWidgetVide import MonWidgetVide
+# widget = MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# from InterfaceQT4.monWidgetPlusieursInto import MonWidgetPlusieursInto
+# widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# elif self.item.waitAssd() and not self.item.waitUserAssdOrAssdMultipleEnCreation() :
+# listeAAfficher = self.item.getSdAvantDuBonType()
+# # a changer selon UserASSD ou UserASSDMultiple
+# mctype=maDefinition.type[0]
+# enable_salome_selection = self.editor.salome and \
+# (('grma' in repr(mctype)) or ('grno' in repr(mctype)) or ('SalomeEntry' in repr(mctype)) or \
+# (hasattr(mctype, "enable_salome_selection") and mctype.enable_salome_selection))
+# if enable_salome_selection:
+# from InterfaceQT4.monWidgetPlusieursBase import MonWidgetPlusieursBase
+# widget=MonWidgetPlusieursBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# elif len(listeAAfficher) == 0:
+# from InterfaceQT4.monWidgetVide import MonWidgetVide
+# widget = MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# elif self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
+# from InterfaceQT4.monWidgetPlusieursASSDIntoOrdonne import MonWidgetPlusieursASSDIntoOrdonne
+# widget=MonWidgetPlusieursASSDIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# from InterfaceQT4.monWidgetPlusieursPlie import MonWidgetPlusieursPlieASSD
+# widget=MonWidgetPlusieursPlieASSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# elif self.item.waitTuple() :
+# if self.item.object.definition.fenetreIhm == 'Tableau' :
+# from InterfaceQT4.monWidgetTableau import MonWidgetTableau
+# widget=MonWidgetTableau(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# num=self.item.object.definition.type[0].ntuple
+# nomDeLaClasse = 'MonWidgetPlusieursTuple'+str(num)
+# nomDuFichier = 'InterfaceQT4.monWidgetPlusieursTupleN'
+# try:
+# _temp = __import__(nomDuFichier, globals(), locals(), [nomDeLaClasse], 0)
+# MonWidgetPlusieursTuple = getattr(_temp,nomDeLaClasse)
+# except :
+# print ("Pas de Tuple de longueur : ", num)
+# print ("Prevenir la maintenance ")
+# widget=MonWidgetPlusieursTuple(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+#
+# elif self.item.hasInto():
+# if self.item.isListSansOrdreNiDoublon():
+#
+# if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
+# from InterfaceQT4.monWidgetPlusieursInto import MonWidgetPlusieursInto
+# widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# from InterfaceQT4.monWidgetPlusieursPlie import MonWidgetPlusieursPlie
+# widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
+# from InterfaceQT4.monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
+# widget=MonWidgetPlusieursIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# from InterfaceQT4.monWidgetPlusieursPlie import MonWidgetPlusieursPlie
+# widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# if self.item.waitUserAssdOrAssdMultipleEnCreation() :
+# from InterfaceQT4.monWidgetPlusieursCreeUserAssd import MonWidgetPlusieursCreeUserAssd
+# widget=MonWidgetPlusieursCreeUserAssd(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# elif self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
+# from InterfaceQT4.monWidgetPlusieursBase import MonWidgetPlusieursBase
+# widget=MonWidgetPlusieursBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+# else :
+# from InterfaceQT4.monWidgetPlusieursPlie import MonWidgetPlusieursPlie
+# widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+#
+# self.widget=widget
+# return widget
+
+
+class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
+ itemNode=Node
+
+ def init(self) :
+ self.expandable = 0
+
+
+ #-----------------------------------------------
+ #
+ # Methodes liees aux informations sur le Panel
+ # ou au mot-clef simple
+ #
+ #-----------------------------------------------
+ # isList
+ # hasInto
+ # getMinMax
+ # getMultiplicite
+ # getIntervalle
+ # getListeValeurs
+ # getListePossible
+
+ def isList(self):
+ """
+ Cette methode indique si le mot cle simple attend une liste (valeur de retour 1)
+ ou s'il n'en attend pas (valeur de retour 0)
+
+ Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
+ Dans le cas sans validateur, l'information est donnee par l'attribut max
+ de la definition du mot cle.
+ Dans le cas avec validateur, il faut combiner l'information precedente avec
+ celle issue de l'appel de la methode isList sur le validateur.On utilisera
+ l'operateur ET pour effectuer cette combinaison (AndVal).
+ """
+ is_a_list=0
+ min,max = self.getMinMax()
+ assert (min <= max)
+ if max > 1 :
+ is_a_list=1
+ # Dans le cas avec validateurs, pour que le mot cle soit considere
+ # comme acceptant une liste, il faut que max soit superieur a 1
+ # ET que la methode isList du validateur retourne 1. Dans les autres cas
+ # on retournera 0 (n'attend pas de liste)
+ if self.definition.validators :
+ is_a_list= self.definition.validators.isList() * is_a_list
+ return is_a_list
+
+ def isListSansOrdreNiDoublon(self):
+ if self.definition.homo=="SansOrdreNiDoublon" : return 1
+ return 0
+
+
+ def hasInto(self):
+ """
+ Cette methode indique si le mot cle simple propose un choix (valeur de retour 1)
+ ou s'il n'en propose pas (valeur de retour 0)
+
+ Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
+ Dans le cas sans validateur, l'information est donnee par l'attribut into
+ de la definition du mot cle.
+ Dans le cas avec validateurs, pour que le mot cle soit considere
+ comme proposant un choix, il faut que into soit present OU
+ que la methode hasInto du validateur retourne 1. Dans les autres cas
+ on retournera 0 (ne propose pas de choix)
+ """
+ has_an_into=0
+ if self.definition.into:
+ has_an_into=1
+ elif self.definition.validators :
+ has_an_into= self.definition.validators.hasInto()
+ return has_an_into
+
+ def hasIntoSug(self):
+ if self.definition.intoSug: return 1
+ return 0
+
+
+ def getMinMax(self):
+ """ Retourne les valeurs min et max de la definition de object """
+ return self.object.getMinMax()
+
+ def getMultiplicite(self):
+ """ A preciser.
+ Retourne la multiplicite des valeurs affectees a l'objet
+ represente par l'item. Pour le moment retourne invariablement 1.
+ """
+ return 1
+
+ def getIntervalle(self):
+ """
+ Retourne le domaine de valeur attendu par l'objet represente
+ par l'item.
+ """
+ return self.object.getintervalle()
+
+ def getListeValeurs(self) :
+ """ Retourne la liste des valeurs de object """
+ valeurs=self.object.getListeValeurs()
+ try :
+ if "R" in self.object.definition.type:
+ clef=self.object.getNomConcept()
+ if clef in self.appliEficas.dict_reels:
+ if type(valeurs) == tuple:
+ valeurs_reelles=[]
+ for val in valeurs :
+ if val in self.appliEficas.dict_reels[clef]:
+ valeurs_reelles.append(self.appliEficas.dict_reels[clef][val])
+ else :
+ valeurs_reelles.append(val)
+ else :
+ if valeurs in self.appliEficas.dict_reels[clef]:
+ valeurs_reelles=self.appliEficas.dict_reels[clef][valeurs]
+ valeurs=valeurs_reelles
+ except :
+ pass
+ return valeurs
+
+ def getListePossible(self,listeActuelle=[]):
+ if hasattr(self.definition.validators,'into'):
+ valeurspossibles = self.definition.validators.into
+ else:
+ valeurspossibles = self.get_definition().into
+
+ if listeActuelle==[] : return valeurspossibles
+
+ #On ne garde que les items valides
+ listevalideitem=[]
+ if type(valeurspossibles) in (list,tuple) :
+ pass
+ else :
+ valeurspossibles=(valeurspossibles,)
+ for item in valeurspossibles:
+ encorevalide=self.valideItem(item)
+ if encorevalide :
+ listevalideitem.append(item)
+
+ #on ne garde que les choix possibles qui passent le test de valideListePartielle
+ listevalideliste=[]
+ for item in listevalideitem:
+ encorevalide=self.valideListePartielle(item,listeActuelle)
+ if encorevalide :
+ listevalideliste.append(item)
+ #print listevalideliste
+ return listevalideliste
+
+ def getListePossibleAvecSug(self,listeActuelle=[]):
+ if hasattr(self.definition,'intoSug'):
+ valeurspossibles = self.definition.intoSug
+ else:
+ return listeActuelle
+
+ if listeActuelle==[] : return valeurspossibles
+ valeurspossibles = valeurspossibles+listeActuelle
+
+ #On ne garde que les items valides
+ listevalideitem=[]
+ if type(valeurspossibles) in (list,tuple) :
+ pass
+ else :
+ valeurspossibles=(valeurspossibles,)
+ for item in valeurspossibles:
+ encorevalide=self.valideItem(item)
+ if encorevalide :
+ listevalideitem.append(item)
+
+ #on ne garde que les choix possibles qui passent le test de valideListePartielle
+ listevalideliste=[]
+ for item in listevalideitem:
+ encorevalide=self.valideListePartielle(item,listeActuelle)
+ if encorevalide :
+ listevalideliste.append(item)
+ return listevalideliste
+
+ def getListeParamPossible(self):
+ liste_param=[]
+ l1,l2=self.jdc.getParametresFonctionsAvantEtape(self.getEtape())
+ for param in self.object.jdc.params:
+ if param.nom not in l1 : continue
+ encorevalide=self.valideItem(param.valeur)
+ if encorevalide:
+ type_param=param.valeur.__class__.__name__
+ for typ in self.definition.type:
+ if typ=='R':
+ liste_param.append(param)
+ if typ=='I' and type_param=='int':
+ liste_param.append(param)
+ if typ=='TXM' and type_param=='str':
+ liste_param.append(repr(param))
+ if ('grma' in repr(typ)) and type_param=='str':
+ liste_param.append(param.nom)
+ return liste_param
+
+ #--------------------------------------------------
+ #
+ # Methodes liees a la validite des valeurs saisies
+ #
+ #---------------------------------------------------
+ # valideItem
+ # valideListePartielle
+ # valideListeComplete
+ # infoErreurItem
+ # infoErreurListe
+ # isInIntervalle
+ # isValid
+
+ def valideItem(self,item):
+ """
+ La validation est realisee directement par l'objet
+ """
+ return self.object.valideItem(item)
+
+ def valideListePartielle(self,item,listecourante):
+ #On protege la liste en entree en la copiant
+ valeur=list(listecourante)
+ if item : valeur.append(item)
+ return self.object.validValeurPartielle(valeur)
+
+ def valideListeComplete (self,valeur):
+ return self.object.validValeur(valeur)
+
+ def infoErreurItem(self) :
+ commentaire=""
+ if self.definition.validators :
+ commentaire=self.definition.validators.infoErreurItem()
+ return commentaire
+
+ def aide(self) :
+ commentaire=""
+ if self.definition.validators :
+ commentaire=self.definition.validators.aide()
+ return commentaire
+
+ def infoErreurListe(self) :
+ commentaire=""
+ if self.definition.validators :
+ commentaire=self.definition.validators.infoErreurListe()
+ return commentaire
+
+ def isInIntervalle(self,valeur):
+ """
+ Retourne 1 si la valeur est dans l'intervalle permis par
+ l'objet represente par l'item.
+ """
+ return self.valideItem(valeur)
+
+ def isValid(self):
+ valide=self.object.isValid()
+ return valide
+
+ #--------------------------------------------------
+ #
+ # Autres ...
+ #
+ #---------------------------------------------------
+ # getIconName
+ # getText
+ # setValeurCo
+ # getSdAvantDuBonType
+
+
+ def getIconName(self):
+ if self.appliEficas.maConfiguration.differencieSiDefaut and self.isValid():
+ if self.object.definition.defaut != None :
+ if self.object.valeur == self.object.definition.defaut : return "ast-green-dark-ball"
+ if self.object.definition.max > 1 and list(self.object.valeur) == list(self.object.definition.defaut) : return "ast-green-dark-ball"
+ return "ast-green-ball"
+ elif self.isValid():
+ return "ast-green-ball"
+ elif self.object.isOblig():
+ return "ast-red-ball"
+ else:
+ return "ast-yel-ball"
+
+ def getText(self):
+ """
+ Classe SIMPTreeItem
+ Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
+ pointe par self
+ """
+ if self.waitUserAssdMultiple() or self.object.waitUserAssd() or self.object.waitAssd(): return self.object.nom
+ text = self.object.getText()
+ if text == None : text=""
+ return text
+
+
+ def setValeurCo(self,nomCo):
+ """
+ Affecte au MCS pointe par self l'objet de type CO et de nom nom_co
+ """
+ ret = self.object.setValeurCo(nomCo)
+ #print "setValeurCo",ret
+ return ret
+
+ def getSdAvantDuBonType(self):
+ """
+ Retourne la liste des noms des SD presentes avant l'etape qui contient
+ le MCS pointe par self et du type requis par ce MCS
+ """
+ # A changer pour tenir compte des UserASSDMultiple
+ # ici on passe par parent pour avoir le bon type
+ #if self.waitUserAssdMultiple() :
+ # l=self.object.parent.getSdCreeParObjetAvecFiltre(self.object)
+ # return l
+ if self.waitUserAssdMultiple() :
+ l=self.object.getUserAssdPossible()
+ return l
+ a=self.object.etape.parent.getSdAvantDuBonType(self.object.etape,self.object.definition.type)
+ if self.waitUserAssd() : l=self.jdc.getSdCreeParObjet(self.object.definition.type)
+ else :l=[]
+ return a+l
+
+ def getSdAvantDuBonTypePourTypeDeBase(self):
+ a=self.object.jdc.getSdAvantDuBonTypePourTypeDe_Base(self.object.etape,"LASSD")
+ return a
+
+ def deleteValeurCo(self,valeur=None):
+ """
+ Supprime la valeur du mot cle (de type CO)
+ il faut propager la destruction aux autres etapes
+ """
+ if not valeur : valeur=self.object.valeur
+ # XXX faut il vraiment appeler delSdprod ???
+ #self.object.etape.parent.delSdprod(valeur)
+ self.object.etape.parent.deleteConcept(valeur)
+
+ #-----------------------------------------------
+ #
+ # Methodes liees au type de l objet attendu
+ #
+ #-----------------------------------------------
+ # waitCo
+ # waitGeom
+ # waitComplex
+ # waitReel
+ # waitAssd
+ # getType
+
+ def waitCo(self):
+ """
+ Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un objet de type ASSD qui n'existe pas encore (type CO()),
+ 0 sinon
+ """
+ return self.object.waitCo()
+
+ def waitFichier(self):
+ maDefinition=self.object.definition
+ try :
+ if ('Repertoire' in maDefinition.type[0]) or ('Fichier' in maDefinition.type[0]) :
+ return 1
+ except :
+ return 0
+
+ def waitGeom(self):
+ """
+ Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un objet GEOM, 0 sinon
+ """
+ return self.object.waitGeom()
+
+ def waitTxm(self):
+ return self.object.waitTxm()
+
+
+ def waitComplex(self):
+ """ Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un complexe, 0 sinon """
+ if 'C' in self.object.definition.type:
+ return 1
+ else:
+ return 0
+
+ def waitReel(self):
+ """ Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un reel, 0 sinon """
+ if 'R' in self.object.definition.type:
+ return 1
+ else:
+ return 0
+
+ def waitTuple(self) :
+ return self.object.waitTuple()
+
+ def waitDate(self):
+ """ Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un reel, 0 sinon """
+ if 'DateHHMMAAAA' in self.object.definition.type:
+ return 1
+ else:
+ return 0
+
+ def waitHeure(self):
+ """ Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un reel, 0 sinon """
+ if 'HeureHHMMSS' in self.object.definition.type:
+ return 1
+ else:
+ return 0
+
+
+
+ def waitTuple(self):
+ """ Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un Tuple, 0 sinon """
+ for ss_type in self.object.definition.type:
+ if repr(ss_type).find('Tuple') != -1 :
+ return 1
+ return 0
+
+ def waitMatrice(self):
+ """ Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un Tuple, 0 sinon """
+ for ss_type in self.object.definition.type:
+ if repr(ss_type).find('Matrice') != -1 :
+ return 1
+ return 0
+
+ def waitAssd(self):
+ """Methode booleenne qui retourne 1 si l'objet pointe par self
+ attend un objet de type ASSD ou derive, 0 sinon """
+ return self.object.waitAssd()
+
+ def waitAssdOrTypeBase(self) :
+ boo=0
+ if len(self.object.definition.type) > 1 :
+ if self.waitReel() :
+ boo = 1
+ if 'I' in self.object.definition.type :
+ boo = 1
+ return boo
+
+ def waitSalome(self):
+ monType = self.object.definition.type[0]
+ if 'grma' in repr(monType) : return True
+ if 'grno' in repr(monType) : return True
+ try :
+ if issubclass(monType, SalomeEntry) : return True
+ except :
+ pass
+ return False
+
+ def getType(self):
+ """
+ Retourne le type de valeur attendu par l'objet represente par l'item.
+ """
+ return self.object.getType()
+
+ #-----------------------------------------------------
+ #
+ # Methodes liees a l evaluation de la valeur saisie
+ #
+ #-----------------------------------------------------
+ # evalValeur
+ # evalValeurItem
+ # isCO
+ # traiteReel
+
+ def evalValeur(self,valeur):
+ """ Lance l'interpretation de 'valeur' (chaine de caracteres) comme valeur de self :
+ - retourne l'objet associe si on a pu interpreter (entier, reel, ASSD,...)
+ - retourne 'valeur' (chaine de caracteres) sinon
+ """
+ newvaleur=self.evalVal(valeur)
+ return newvaleur,1
+
+
+ def evalValeurItem(self,valeur):
+ """ Lance l'interpretation de 'valeur' qui doit ne pas etre un tuple
+ - va retourner la valeur de retour et la validite
+ selon le type de l objet attendu
+ - traite les reels et les parametres
+ """
+ #print "evalValeurItem",valeur
+ if valeur==None or valeur == "" :
+ return None,0
+ validite=1
+ if self.waitReel():
+ valeurinter = self.traiteReel(valeur)
+ if valeurinter != None :
+ valeurretour,validite= self.object.evalValeur(valeurinter)
+ else:
+ valeurretour,validite= self.object.evalValeur(valeur)
+ elif self.waitGeom():
+ valeurretour,validite = valeur,1
+ else :
+ valeurretour,validite= self.object.evalValeur(valeur)
+
+ if validite == 0:
+ if (type(valeur) == bytes or type(valeur) == str )and self.object.waitTxm():
+ essai_valeur="'" + valeur + "'"
+ valeurretour,validite= self.object.evalValeur(essai_valeur)
+
+ if hasattr(valeurretour,'__class__'):
+ #if valeurretour.__class__.__name__ in ('PARAMETRE','PARAMETRE_EVAL'):
+ if valeurretour.__class__.__name__ in ('PARAMETRE',):
+ validite=1
+
+ #if self.waitCo():
+ # CCAR : il ne faut pas essayer de creer un concept
+ # il faut simplement en chercher un existant ce qui a du etre fait par self.object.evalValeur(valeur)
+ #try:
+ #valeurretour=Accas.CO(valeur)
+ #except:
+ #valeurretour=None
+ #validite=0
+ # on est dans le cas ou on a evalue et ou on n'aurait pas du
+ if self.object.waitTxm() :
+ if type(valeurretour) != bytes:
+ valeurretour=str(valeur)
+ validite=1
+ return valeurretour,validite
+
+ def isCO(self,valeur=None):
+ """
+ Indique si valeur est un concept produit de la macro
+ Cette methode n'a de sens que pour un MCSIMP d'une MACRO
+ Si valeur vaut None on teste la valeur du mot cle
+ """
+ # Pour savoir si un concept est un nouveau concept de macro
+ # on regarde s'il est present dans l'attribut sdprods de l'etape
+ # ou si son nom de classe est CO.
+ # Il faut faire les 2 tests car une macro non valide peut etre
+ # dans un etat pas tres catholique avec des CO pas encore types
+ # et donc pas dans sdprods (resultat d'une exception dans typeSDProd)
+ if not valeur:valeur=self.object.valeur
+ if valeur in self.object.etape.sdprods:return 1
+ #if type(valeur) is not types.InstanceType:return 0
+ if type(valeur) is not object:return 0
+ if valeur.__class__.__name__ == 'CO':return 1
+ return 0
+
+ def isParam(self,valeur) :
+ for param in self.jdc.params:
+ if (repr(param) == valeur):
+ return 1
+ return 0
+
+ def traiteReel(self,valeur):
+ """
+ Cette fonction a pour but de rajouter le '.' en fin de chaine pour un reel
+ ou de detecter si on fait reference a un concept produit par DEFI_VALEUR
+ ou un EVAL ...
+ """
+ valeur = valeur.strip()
+ liste_reels = self.getSdAvantDuBonType()
+ if valeur in liste_reels:
+ return valeur
+ if len(valeur) >= 3 :
+ if valeur[0:4] == 'EVAL' :
+ # on a trouve un EVAL --> on retourne directement la valeur
+ return valeur
+ if valeur.find('.') == -1 :
+ # aucun '.' n'a ete trouve dans valeur --> on en rajoute un a la fin
+ if (self.isParam(valeur)):
+ return valeur
+ else:
+ if valeur.find('e') != -1:
+ # Notation scientifique ?
+ try :
+ r=eval(valeur)
+ return valeur
+ except :
+ return None
+ else :
+ return valeur+'.'
+ else:
+ return valeur
+
+
+import Accas
+treeitem = SIMPTreeItem
+objet = Accas.MCSIMP
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from __future__ import absolute_import
+from __future__ import print_function
+
+import types,sys,os, re
+import traceback
+
+
+# Modules Eficas
+from Extensions.i18n import tr
+
+from Editeur import session
+from Editeur import comploader
+from Editeur import Objecttreeitem
+
+debug = False
+
+
+from InterfaceSsIhm.editorSsIhm import JDCEditorSsIhm
+
+
+class JDCWebEditor(JDCEditorSsIhm):
+# ----------------------------------------- #
+ """
+ Editeur de jdc
+ """
+
+ def __init__ (self,appliEficas,fichier = None, jdc=None ):
+ #------------------------------------------------------------------------------------------------
+
+ JDCEditorSsIhm.__init__(self,appliEficas,fichier)
+ comploader.chargerComposants(Ihm='Web')
+ if self.jdc:
+ print (self.jdc)
+ self.jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
+
+
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+from __future__ import absolute_import
+try :
+ from builtins import object
+except : pass
+
+
+from Extensions.i18n import tr
+import types
+
+#---------------------------#
+class PopUpMenuRacine(object) :
+#---------------------------#
+
+ def createPopUpMenu(self):
+ print ("createPopUpMenu de MenuRacine")
+
+
+ def addParametersApres(self):
+ print ("addParametersApres de MenuRacine")
+
+#---------------------------#
+class PopUpMenuNodeMinimal(object) :
+#---------------------------#
+
+ def createPopUpMenu(self):
+ print ("createPopUpMenu de PopUpMenuNodeMinimal")
+
+ def createActions(self):
+ print ("createActions")
+
+ def supprimeNoeud(self):
+ print ("supprimeNoeud")
+
+ def viewDoc(self):
+ print ("viewDoc")
+
+ def addParametersApres(self):
+ print ("addParametersApres")
+
+ def addParametersAvant(self):
+ print ("addParametersAvant")
+
+ def addCommApres(self):
+ print ("addCommApres")
+
+ def addCommAvant(self):
+ print ("addCommAvant")
+
+ def deplieCeNiveau(self):
+ print ("deplieCeNiveau")
+
+#--------------------------------------------#
+class PopUpMenuNodePartiel (PopUpMenuNodeMinimal):
+#---------------------------------------------#
+ def createPopUpMenu(self):
+ PopUpMenuNodeMinimal.createPopUpMenu(self)
+ print ("createPopUpMenu de PopUpMenuNodePartiel")
+
+
+#-----------------------------------------#
+class PopUpMenuNode(PopUpMenuNodePartiel) :
+#-----------------------------------------#
+ def createPopUpMenu(self):
+ PopUpMenuNodePartiel.createPopUpMenu(self)
+ print ("createPopUpMenu de PopUpMenuNode")
+
+ def commenter(self):
+ print ("commenter")
min=1, max=1, homo=1, position='local',filtre=None,
val_min=float('-inf'), val_max=float('inf'), docu="", validators=None, nomXML=None,
sug=None,fenetreIhm=None, attribut=False, sortie='n', intoXML=None, metAJour=None,
- avecBlancs=False):
+ avecBlancs=False, unite=None):
"""
Un mot-clé simple est caractérisé par les attributs suivants :
- type : cet attribut est obligatoire et indique le type de valeur attendue
self.sortie = sortie
self.filtre = filtre
self.avecBlancs = avecBlancs
+ self.unite = unite
if not(self.avecBlancs) and self.max > 1 and 'TXM' in self.type and self.into != None :
for val in self.into :
- if val.find(' ') :
+ if val.find(' ') > -1:
self.avecBlancs = True
break
- if not(self.avecBlancs) and self.max > 1 and 'TXM' in self.type and self.into != None :
+ if not(self.avecBlancs) and self.max > 1 and 'TXM' in self.type and self.intoXML != None :
for val in self.intoXML :
- if val.find(' ') :
+ if val.find(' ') > -1:
self.avecBlancs = True
break
if self.avecBlancs and not ('TXM' in self.type) :
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2021 EDF R&D
+#
+# This library is free software; you can redistribute it and/or
+# modify it under the terms of the GNU Lesser General Public
+# License as published by the Free Software Foundation; either
+# version 2.1 of the License.
+#
+# This library is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+#
+# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
+#
+"""
+ Ce module sert a lancer EFICAS configure pour MAP
+"""
+# Modules Python
+# Modules Eficas
+import prefs
+name='prefs_'+prefs.code
+__import__(name)
+
+import os, sys
+sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..'))
+
+import prefs
+from InterfaceSsIhm import eficas_go
+eficas_go.lanceEficas_Web(code=prefs.code)
+++ /dev/null
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""
- Ce module sert a lancer EFICAS configure pour MAP
-"""
-# Modules Python
-# Modules Eficas
-import prefs
-name='prefs_'+prefs.code
-__import__(name)
-
-import os, sys
-sys.path.append(os.path.join(os.path.abspath(os.path.dirname(__file__)),'..'))
-
-import prefs
-from InterfaceSsIhm import eficas_go
-eficas_go.lanceEficas_Web(code=prefs.code)
+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2007-2021 EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-from __future__ import absolute_import
-from __future__ import print_function
-try :
- from builtins import str
- from builtins import range
-except : pass
-
-import types,sys,os, re
-import subprocess
-import traceback
-
-
-import traceback
-
-# Modules Eficas
-
-import convert, generator
-from Editeur import session
-from Editeur import comploader
-from Editeur import Objecttreeitem
-
-DictExtensions= {"MAP" : ".map", "TELEMAC" : '.cas'}
-debug = False
-
-
-
-class JDCEditorSsIhm :
-# ------------------- #
- """
- Editeur de jdc
- """
-
-# ---------------------------------------------
-# Methodes Communes ou appelees depuis avec Ihm
-# ---------------------------------------------
-
- def __init__ (self,appliEficas,fichier = None, jdc = None, units = None, include=0 ):
- #-----------------------------------------------------------------------------------#
- # paticularisee avec Ihm
-
- if debug : print ('dans le init de JDCEditorSsIhm')
- self.appliEficas = appliEficas
- self.fichier = fichier
- self.fichierComplet = fichier
- if fichier != None : self.extensionFichier = os.path.splitext(fichier)[1]
- else : self.extensionFichier = None
- self.jdc = jdc
- self.first = True
- self.jdc_item = None
- self.dicoNouveauxMC = {}
- self.dicoNouveauxFact = {}
- self.dict_reels = {}
- self.liste_simp_reel = []
-
- if self.appliEficas != None : self.salome = self.appliEficas.salome
- else : self.salome = 0
-
- # ces attributs sont mis a jour par definitCode appelee par newEditor
- self.code = self.appliEficas.maConfiguration.code
- self.maConfiguration = self.appliEficas.maConfiguration
-
-
- if not hasattr ( self.appliEficas, 'readercata') or self.appliEficas.readercata.demandeCatalogue==True or self.appliEficas.multi==True:
- if self.maConfiguration.typeDeCata == 'XML' :
- from . import readercataXML as readercata
- else :
- from . import readercata
- self.readercata = readercata.ReaderCata( self, self.appliEficas )
- self.appliEficas.readercata=self.readercata
- self.appliEficas.code=self.code
- else :
- self.readercata=self.appliEficas.readercata
- if self.readercata.fichierCata == None : return #Sortie Salome
- self.titre=self.readercata.titre
-
- self.formatFichierOut = self.appliEficas.formatFichierOut
- self.formatFichierIn = self.appliEficas.formatFichierIn
-
- #if self.appliEficas.maConfiguration.dumpXSD==True : self.appliEficas.dumpXsd()
- self.dict_reels={}
- self.liste_simp_reel=[]
- self.dicoNouveauxMC={}
- self.dicoNouveauxFact={}
-
-
- try:
- self.maConfiguration.generator_module
- _module = __import__(self.maConfiguration.generator_module)
- info = _module.entryPoint()
- generator.plugins.addEntryPoint(info)
- except:
- pass
-
- try:
- self.maConfiguration.convert_module
- #print self.maConfiguration.convert_module
- _module = __import__(self.maConfiguration.convert_module)
- info = _module.entryPoint()
- convert.plugins.addEntryPoint(info)
- except :
- pass
-
- self.maConfiguration.mesGenerators = generator
- self.maConfiguration.mesconvertisseurs = convert
- try : self.XMLgenerator=generator.plugins['xml']()
- except : self.XMLgenerator=None
-
-
- if self.formatFichierOut in generator.plugins.keys():
- self.generator = generator.plugins[self.formatFichierOut]()
-
-
- self.fileInfo = None
- self.lastModified = 0
-
- self.modified = False
- self.isReadOnly = False
-
- #------- construction du jdc --------------
-
-
- self.nouveau=0
- if self.fichier is not None: # fichier jdc fourni
- if jdc==None :
- #print ('PNPN : chgt try en if')
- try :
- #if 1 :
- self.jdc = self.readFile(self.fichier)
- except :
- print ("mauvaise lecture du fichier")
- if self.salome :
- try : self.appliEficas.addJdcInSalome( self.fichier)
- except : print ("mauvais enregistrement dans Salome")
- else :
- self.jdc=jdc
-
- if self.jdc is not None and units is not None:
- self.jdc.recorded_units=units
- self.jdc.old_recorded_units=units
-
- else:
- if not self.jdc: # nouveau jdc
- if not include : self.jdc = self._newJDC(units=units)
- else : self.jdc = self._newJDCInclude(units=units)
- self.nouveau=1
-
- if self.jdc:
- self.jdc.editor = self
- self.jdc.lang = self.appliEficas.langue
- self.jdc.aReafficher=False
- txt_exception = None
- if not jdc:
- if self.extensionFichier == '.xml' :
- if self.appliEficas.maConfiguration.withXSD: self.jdc.analyseXML()
- else : print ('run MDM with -x option (MDM for XML)'); exit()
- else : self.jdc.analyse()
- txt_exception = self.jdc.cr.getMessException()
- if txt_exception :
- self.jdc = None
- self.informe('pb chargement jdc',txt_exception)
- #else:
- #comploader.chargerComposants()
- #self.jdc_item=Objecttreeitem.makeObjecttreeitem( self, "nom", self.jdc )
-
- #-------------------------------#
- def readFile(self, fn):
- #--------------------------------#
- """
- Public slot to read the text from a file.
- @param fn filename to read from (string or QString)
- """
-
- # charge un JDC
- # paticularisee avec Ihm
-
- fn = str(fn)
- jdcName=os.path.basename(fn)
-
- # Il faut convertir le contenu du fichier en fonction du format
- formatIn=self.appliEficas.formatFichierIn
- if self.extensionFichier == '.xml' and self.appliEficas.maConfiguration.withXSD: formatIn='xml'
- if formatIn in convert.plugins:
- # Le convertisseur existe on l'utilise
- p=convert.plugins[formatIn]()
- p.readfile(fn)
-
- if p.text=="" : self.nouveau=1
- #print ('PNPN --> CIST a faire')
-
- if formatIn != 'xml':
- pareil,texteNew=self.verifieChecksum(p.text)
- if not pareil : self.informe(("fichier modifie"),("Attention! fichier change hors EFICAS"),False)
- p.text=texteNew
- memeVersion,texteNew=self.verifieVersionCataDuJDC(p.text)
- if memeVersion == 0 : texteNew=self.traduitCatalogue(texteNew)
- p.text=texteNew
- text=p.convert('exec',self.appliEficas)
- if not p.cr.estvide(): self.afficheInfos("Erreur a la conversion",'red')
- else:
- text=p.text
- else :
- self.afficheInfos("Type de fichier non reconnu",'red')
- self.informe( "Type de fichier non reconnu",
- "EFICAS ne sait pas ouvrir le type de fichier " + self.appliEficas.formatFichierIn)
- return None
-
- CONTEXT.unsetCurrentStep()
-
- #jdc=self.readercata.cata[0].JdC(procedure=text,
- jdc=self.readercata.cata.JdC(procedure=text,
- appliEficas=self.appliEficas,
- cata=self.readercata.cata,
- cata_ord_dico=self.readercata.cata_ordonne_dico,
- nom=jdcName,
- rep_mat=self.maConfiguration.rep_mat
- )
- self.modified = False
- return jdc
-
-
- #--------------------------------#
- def _newJDC( self ,units = None):
- #--------------------------------#
- """
- Initialise un nouveau JDC vierge
- """
- self.modified=1
- CONTEXT.unsetCurrentStep()
-
- texte=""
- if self.code == "CARMELCND" : texte=self._newJDCCND()
- if self.code == "ZCRACKS" : texte=self._newZCRACKS()
- if self.code == "PSEN" : texte = self._newPSEN()
- if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
-
- if hasattr(self.readercata.cata,'TEXTE_NEW_JDC') : texte=self.readercata.cata.TEXTE_NEW_JDC
-
-
- jdc=self.readercata.cata.JdC( procedure =texte,
- appliEficas=self.appliEficas,
- cata=self.readercata.cata,
- cata_ord_dico=self.readercata.cata_ordonne_dico,
- rep_mat=self.maConfiguration.rep_mat
- )
-
- jdc.lang = self.appliEficas.langue
- if units is not None:
- jdc.recorded_units=units
- jdc.old_recorded_units=units
- # chgt le 15/10/19
- # Attention positionne contexte ?
- # est ce qu on ne doit pas changer le format en Accas si on vient d accas ?
- jdc.editor=self
- return jdc
-
- #--------------------------------#
- def _newJDCInclude( self ,units = None):
- #--------------------------------#
- """
- Initialise un nouveau JDC vierge
- """
- import Extensions.jdc_include
- JdC_aux=Extensions.jdc_include.JdC_include
- CONTEXT.unsetCurrentStep()
-
- #jaux=self.readercata.cata[0].JdC( procedure="",
- jaux=self.readercata.cata.JdC( procedure="",
- appliEficas=self.appliEficas,
- cata=self.readercata.cata,
- cata_ord_dico=self.readercata.cata_ordonne_dico,
- rep_mat=self.maConfiguration.rep_mat,
- )
- jaux.editor=self
- jaux.analyse()
-
- J=JdC_aux( procedure="",
- appliEficas=self.appliEficas,
- cata=self.readercata.cata,
- cata_ord_dico=self.readercata.cata_ordonne_dico,
- jdc_pere=jaux,
- rep_mat=self.maConfiguration.rep_mat,
- )
- J.editor=self
- J.analyse()
- if units is not None:
- J.recorded_units=units
- J.old_recorded_units=units
- return J
-
-
-
- #-----------------------#
- def getSource(self,file):
- #-----------------------#
-
- # Il faut convertir le contenu du fichier en fonction du format
- if self.formatFichierIn in convert.plugins :
- # Le convertisseur existe on l'utilise
- p=convert.plugins[self.formatFichierIn]()
- p.readfile(file)
- text=p.convert('execnoparseur')
- if not p.cr.estvide():
- self.afficheInfos("Erreur a la conversion",'red')
- return text
- else:
- # Il n'existe pas c'est une erreur
- self.afficheInfos("Type de fichier non reconnu",'red')
- self.informe( "Type de fichier non reconnu",
- "EFICAS ne sait pas ouvrir le type de fichier " + self.appliEficas.formatFichierIn)
- return None
-
- #----------------------------------------------#
- def __generateTempFilename(self, prefix, suffix):
- #----------------------------------------------#
- import tempfile
- (fd, filename) = tempfile.mkstemp(prefix=prefix, suffix=suffix)
- os.close(fd)
- return filename
-
- #-----------------------#
- def generDico(self):
- #-----------------------#
- if 'dico' in generator.plugins:
- self.generator=generator.plugins['dico']()
- #print (self.generator)
- jdc_formate=self.generator.gener(self.jdc)
- #print (jdc_formate)
- dico=self.generator.Dico
- #print (dico)
- return dico
-
- #-----------------------#
- def viewJdcSource(self):
- #-----------------------#
- if self.fichier == None : return
- if os.path.isfile(self.fichier):
- f=open(self.fichier,'r')
- texteSource=f.read()
- f.close()
- self._viewText(texteSource, "JDC_SOURCE")
- else :
- self._viewText("file doesn't exist", "JDC_SOURCE")
-
-
- #-----------------------#
- def viewJdcPy(self):
- #-----------------------#
- strSource = str( self.getTextJDC(self.formatFichierOut) )
- self._viewText(strSource, "JDC_RESULTAT")
-
- #-----------------------#
- def viewJdcRapport(self):
- #-----------------------#
- # on ajoute les regles
- strRapport = str( self.jdc.report() )
- self._viewText(strRapport, "JDC_RAPPORT")
-
- #-----------------------#
- def viewJdcRegles(self):
- #-----------------------#
- # on ajoute les regles
- texte_global, test_global = self.jdc.verifRegles()
- self._viewText(texte_global, "JDC_REGLES")
-
- #-----------------------#
- def getJdcRapport(self):
- #-----------------------#
- # on ajoute les regles
- strRapport = str( self.jdc.report() )
- return strRapport
-
- #---------------------#
- def getFileName(self):
- #---------------------#
- return self.fichier
-
- #-------------------#
- def initModif(self):
- #-------------------#
- """
- Met l'attribut modified a 'o' : utilise par Eficas pour savoir
- si un JDC doit etre sauvegarde avant destruction ou non
- """
- self.modified = True
-
-
- #--------------------------------------------------#
- def writeFile(self, fn, txt = None,formatLigne="beautifie"):
- #--------------------------------------------------#
- """
- Public slot to write the text to a file.
-
- @param fn filename to write to string
- @return flag indicating success
- """
-
- fn = str(fn)
-
- if txt == None :
- txt = self.getTextJDC(self.formatFichierOut,formatLigne=formatLigne)
- eol = '\n'
- if len(txt) >= len(eol):
- if txt[-len(eol):] != eol:
- txt += eol
- else:
- txt += eol
- txt=self.ajoutVersionCataDsJDC(txt)
- if self.code != 'PSEN' and self.code != 'PSEN_N1' : checksum=self.getChecksum(txt)
- else : checksum=''
- txt=txt+checksum
- if self.code=="TELEMAC" : return 1
- try:
- f = open(fn, 'w')
- f.write(txt)
- f.close()
- return 1
- except IOError as why:
- print('Sauvegarde du Fichier', 'Le fichier'+str(fn) + 'n a pas pu etre sauvegarde :' , str(why))
- self.afficheInfos('Le fichier'+str(fn) + 'n a pas pu etre sauvegarde ' , 'red')
- return 0
-
-
- #-----------------------------------------------------------#
- def getTextJDC(self,format = None,pourRun=0,formatLigne="beautifie"):
- #-----------------------------------------------------------#
- if self.code == "MAP" and not(format in generator.plugins): format = "MAP"
- if format == None : format = self.formatFichierOut
- if format in generator.plugins:
-
- # Le generateur existe on l'utilise
- self.generator=generator.plugins[format]()
- try :
- jdc_formate=self.generator.gener(self.jdc,format=formatLigne,config=self.appliEficas.maConfiguration,appliEficas=self.appliEficas)
- if pourRun : jdc_formate=self.generator.textePourRun
- if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico
- except ValueError as e:
- self.informe( "Erreur a la generation",str(e),'red')
- return
-
- if not self.generator.cr.estvide():
- self.informe("Erreur a la generation","EFICAS ne sait pas convertir ce JDC",'red')
- return ""
- else:
- return jdc_formate
- else:
- # Il n'existe pas c'est une erreur
- self.informe("Format inconnu", self.format + " non reconnu" )
- return ""
-
- #------------------------------#
- def verifieChecksum(self,text):
- #------------------------------#
- # Attention : souci sous Windows
- #
- indexDeb=text.find("#CHECKSUM:")
- if indexDeb < 0 : return 1, text
- indexFin=text.find(":FIN CHECKSUM")
- checkAvant=text[indexDeb:indexFin+13]
- textJDC=text[0:indexDeb]+text[indexFin+13:-1]
- if self.code != 'PSEN' and self.code != 'PSEN_N1':
- checksum=self.getChecksum(textJDC)
- pareil=(checkAvant==checksum)
- else :
- pareil=1
- return pareil, textJDC
-
- #---------------------------#
- def getChecksum(self,texte):
- #---------------------------#
- try :
- import haslib
- newtexte=texte.replace('"','\\"')
- hash_checksum = hashlib.md5()
- hash_checksum.update(newtexte.encode('utf-8'))
- checksum = hash_checksum.hexdigest()
- ligne = ligne="#CHECKSUM:"+checksum+":FIN CHECKSUM"
- except :
- try :
- newtexte=texte.replace('"','\\"')
- commande='echo "'+newtexte+'"|md5sum'
- a=os.popen(commande)
- checksum=a.read()
- a.close()
- except :
- checksum='Fichier trop long \n'
- ligne="#CHECKSUM:"+checksum[0:-1]+":FIN CHECKSUM"
- return ligne
-
- #----------------------#
- def getDico(self):
- #---------------------#
- if 'dicoImbrique' in generator.plugins:
- self.generator=generator.plugins['dicoImbrique']()
- #print (self.generator)
- jdc_formate=self.generator.gener(self.jdc)
- dico=self.generator.Dico
- return dico
- else :
- self.afficheInfos(tr("Format %s non reconnu" , 'Dictionnaire Imbrique' ),'red')
- return ""
-
- #-----------------------------------------#
- def chercheGroupes(self):
- #-----------------------------------------#
- listeMA,listeNO=self.getTextJDC("GroupMA")
- return listeMA,listeNO
-
- #-----------------------------------------#
- def chercheDico(self):
- #-----------------------------------------#
- dicoCourant={}
- format = self.appliEficas.formatFichierOut
- if format in generator.plugins:
- # Le generateur existe on l'utilise
- self.generator=generator.plugins[format]()
- jdc_formate=self.generator.gener(self.jdc,format='beautifie',config=self.appliEficas.maConfiguration)
- dicoCourant=self.generator.dico
- return dicoCourant
-
- #-----------------------------------------------------------------#
- def saveFileLegerAs(self, fileName = None) :
- #-----------------------------------------------------------------#
- if fileName != None :
- self.fichier = fileName
- return self.saveFileLeger(fileName)
- return self.saveFileLeger()
-
- #-----------------------------------------------------------------#
- def saveFileComplet(self, fichier = None, formatLigne="beautifie"):
- #-----------------------------------------------------------------#
- fn = fichier
- self.generator=generator.plugins[self.format]()
- print (self.generator)
- if hasattr(self.generator, "writeComplet"):
- self.generator.writeComplet(fichier,self.jdc,config=self.appliEficas.maConfiguration,appliEficas=self.appliEficas)
-
-
-# ---------------------------------------------
-# Methodes Surchargees par avecIhm
-# ---------------------------------------------
-
- #--------------------------------#
- def ajoutCommentaire(self):
- #--------------------------------#
- print ('pas programme sans Ihm')
- print ('prevenir la maintenance du besoin')
-
-
- #--------------------------------------#
- def informe(self,titre,txt,critique=True):
- #--------------------------------------#
- # methode differenre avec et sans ihm
- if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
- print (titre)
- print (txt)
- if critique : print ('!!!!!!!!!!!!!!!!!!!!!!!!!!!')
-
- #--------------------------------------#
- def afficheInfos(self,txt,couleur=None):
- #--------------------------------------#
- # methode differenre avec et sans ihm
- print (txt)
-
- #-----------------------------------------------------------------------#
- def _viewText(self, txt, caption = "FILE_VIEWER",largeur=1200,hauteur=600):
- #--------------------------------------------------------------------#
- print ('_____________________________')
- print (txt)
- print ('_____________________________')
-
-
- #-----------------------------------------------------------------#
- def saveFile(self, fichier, formatLigne="beautifie"):
- #-----------------------------------------------------------------#
- """
- Public slot to save the text to a file.
-
- @param path directory to save the file in (string or QString)
- @return tuple of two values (boolean, string) giving a success indicator and
- the name of the saved file
- """
-
-
- self.fichierOut = fichier
- if self.appliEficas.maConfiguration.fichierXML !=None : self.jdc.analyseXML()
- if not (self.writeFile(fichier,formatLigne=formatLigne)): return (0, None)
- if self.jdc.cata.modeleMetier and self.jdc.isValid():
- if self.generator != self.XMLgenerator :
- self.XMLgenerator.gener(self.jdc)
- self.XMLgenerator.writeDefault(fichier)
- return(1,self.fichier)
- if self.jdc.isValid() and hasattr(self.generator, "writeDefault"):
- self.generator.writeDefault(fichier)
- elif self.code=="TELEMAC" and hasattr(self.generator, "writeDefault"):
- self.generator.writeDefault(fichier)
- self.modified = 0
- return (1, self.fichier)
-#
-
- #----------------------------------------------#
- def sauveLigneFile(self):
- #----------------------------------------------#
- self.modified=1
- return self.saveFile(formatLigne="Ligne")
-
-
- #-----------------------------------#
- def updateJdc(self, itemApres,texte):
- #------------------------------------#
- # ajoute une etape de JdC a partir d un texte
- monItem=itemApres
- etape=monItem.item.object
- CONTEXT.setCurrentStep(etape)
- etape.buildIncludeInclude(texte)
- self.tree.racine.buildChildren()
-
- #-----------------------------------#
- def updateJdcEtape(self, itemApres,texte):
- #------------------------------------#
- # ajoute une etape de JdC a partir d un texte
- monItem=itemApres
- etape=monItem.item.object
- CONTEXT.set_current_step(etape)
- try :
- ok=etape.build_includeEtape(texte)
- except :
- ok=0
- if not ok :
- QMessageBox.information( self,
- tr("Import texte"),
- tr("Impossible d importer le texte"))
- self.tree.racine.build_children()
- return ok
-
-
-
- #-------------------------------------#
- def deleteEtape(self,etape):
- #-------------------------------------#
- # dans le JDC
- self.jdc.suppentite(etape)
-
- #-------------------------------------#
- def deleteMC(self,etape,MCFils,listeAvant=()):
- #-------------------------------------#
- # dans le JDC
- ouChercher=etape
- for mot in listeAvant :
- ouChercher=ouChercher.getChild(mot,restreint="oui")
- monMC=ouChercher.getChild(MCFils,restreint="oui")
- if monMC != None : ouChercher.suppentite(monMC)
- ouChercher.state='changed'
- ouChercher.isvalid()
-
- #--------------------------------------------------------#
- def ajoutMC(self,etape,MCFils,valeurs,listeAvant=()):
- #--------------------------------------------------------#
- # dans le JDC
- debug=False
- if debug : print ('ajoutMC', etape,MCFils,valeurs,listeAvant)
- ouChercher=etape
- if debug : print (ouChercher)
- for mot in listeAvant :
- ouChercher=ouChercher.getChild(mot,restreint="oui")
- monMC=ouChercher.getChild(MCFils,restreint="oui")
- if monMC == None : monMC = ouChercher.addEntite(MCFils)
- monMC.valeur=valeurs
- monMC.val=valeurs
- monMC.state='changed'
- monMC.isvalid()
- return 1
-
- #--------------------------------------------------------#
- def ajoutMCinMCFactUnique(self,etape,MCFils,valeurs,listeAvant=()):
- # Attention si +sieursMCFACT
- #--------------------------------------------------------#
- # dans le JDC
- debug=False
- if debug : print ('ajoutMC', etape,MCFils,valeurs,listeAvant)
- ouChercher=etape
- if debug : print (ouChercher)
- for mot in listeAvant :
- ouChercher=ouChercher.getChild(mot,restreint="oui")
- # Attention si +sieursMCFACT
- ouChercher=ouChercher[0]
- if debug : print (ouChercher)
- monMC=ouChercher.getChild(MCFils,restreint="oui")
- if monMC == None : monMC = ouChercher.addEntite(MCFils)
- monMC.valeur=valeurs
- monMC.val=valeurs
- monMC.state='changed'
- monMC.isValid()
- return 1
-
- #----------------------------------------------#
- def ajoutMCFact(self,etape,MCFils,listeAvant=()):
- #----------------------------------------------#
- # dans le JDC
- ouChercher=etape
- for mot in listeAvant :
- ouChercher=ouChercher.getChild(mot,restreint="oui")
- monMC=etape.getChild(ouChercher,restreint="oui")
- if monMC== None : monMC= ouChercher.addEntite(MCFils)
- monMC.isvalid()
-
- #-----------------------------------------------------------------#
- def setValeurMCSimpInEtape(self,etape,listeAvant,valeur):
- #-----------------------------------------------------------------#
- # pour VP
- monObj=etape
- for mot in listeAvant :
- monObj=monObj.getChild(mot,restreint="oui")
- if monObj==None : return False
- if monObj == None : return False
- if monObj.valeur != valeur :
- # PNPN le setValeur fait des bugs --> pourquoi
- #monObj.setValeur(valeur)
- monObj.valeur=valeur
- monObj.isValid()
- return True
-
- #-------------------------------------------------#
- def getValeur(self,nomEtape,MCFils,listeAvant=()):
- #-------------------------------------------------#
- # dans le JDC
-
- debug=0
- ouChercher=None
- for e in self.jdc.etapes:
- if e.nom == nomEtape : ouChercher=e; break
- if debug : print ('etape trouvee', ouChercher)
- if ouChercher==None : return None
- for mot in listeAvant :
- ouChercher=ouChercher.getChild(mot,restreint="oui")
- if debug : print (mot, ouChercher)
- if ouChercher==None : return None
- monMC=ouChercher.getChild(MCFils,restreint="oui")
- if debug : print ('monMC', monMC)
- if monMC== None : return None
- return monMC.valeur
-
- #-------------------------------------------------#
- def getMCDsEtape(self,etape,MCFils,listeAvant=()):
- #-------------------------------------------------#
- # dans le JDC
-
- if etape==None : return None
- ouChercher=etape
- debug=0
- for mot in listeAvant :
- ouChercher=ouChercher.getChild(mot,restreint="oui")
- if debug : print (mot, ouChercher)
- if ouChercher==None : return None
- monMC=ouChercher.getChild(MCFils,restreint="oui")
- if debug : print ('monMC', monMC)
- return monMC
-
- #-----------------------------------------------------------#
- def setValeur(self,nomEtape,MCFils,valeur,listeAvant=()):
- #--------------------------------------------------------#
- # dans le JDC
-
- ouChercher=None
- for e in self.jdc.etapes:
- if e.nom == nomEtape : ouChercher=e; break
- if ouChercher==None : return None
- for mot in listeAvant :
- ouChercher=ouChercher.getChild(mot,restreint="oui")
- #print (mot, ouChercher)
- if ouChercher==None : return None
- monMC=ouChercher.getChild(MCFils,restreint="oui")
- monMC.set_valeur(valeur)
- monMC.isvalid()
-
- #-----------------------------------------------------------#
- def changeIntoMC(self,etape,MCFils,valeurs, listeAvant=()):
- #-----------------------------------------------------------#
- # dans le JDC
- ouChercher=etape
- if isinstance (etape, str):
- ouChercher=None
- for e in self.jdc.etapes:
- if e.nom == etape : ouChercher=e; break
- if ouChercher==None : return
-
- for mot in listeAvant :
- ouChercher=ouChercher.getChild(mot,restreint="oui")
- if ouChercher==None : return
- monMC=ouChercher.getChild(MCFils,restreint="oui")
- if monMC== None : monMC= ouChercher.addEntite(MCFils)
-
- monMC.definition.into=valeurs
- from Noyau.N_VALIDATOR import IntoProtocol
- monMC.definition.intoProto = IntoProtocol("into", into=monMC.definition.into, val_min=monMC.definition.val_min, val_max=monMC.definition.val_max)
- monMC.state='changed'
- monMC.isvalid()
-
- #-------------------------------------------------------------------#
- def reCalculeValiditeMCApresChgtInto(self,nomEtape,MCFils,listeAvant=()):
- #-------------------------------------------------------------------#
- # dans le JDC
- for e in self.jdc.etapes:
- if e.nom == nomEtape : ouChercher=e; break
-
- for mot in listeAvant :
- try :
- ouChercher=ouChercher.getChild(mot,restreint="oui")
- # Le mot clef n est pas la
- except : return 0
- try :
- monMC=ouChercher.getChild(MCFils,restreint="oui")
- # Le mot clef n est pas la
- except : return 0
- if monMC == None : return 0
-
- if hasattr(monMC.definition,'into') :
- if type(monMC.definition.into) ==types.FunctionType : maListeDeValeur=monMC.definition.into()
- else : maListeDeValeur=monMC.definition.into
- else :
- return 0
-
- monMC.state='changed'
- return 1
-
- def dumpXsd(self, avecEltAbstrait = False):
- #-----------------------------------------#
- texteXSD = self.readercata.cata.JdC.dumpXsd(avecEltAbstrait)
- return texteXSD
-
- def dumpStructure(self):
- #----------------------------#
- texteStructure = self.readercata.cata.JdC.dumpStructure()
- return texteStructure
-
- #-------------------------------------#
- def changeDefautDefMC(self,nomEtape,listeMC,valeurs):
- #-------------------------------------#
- # dans le MDD
-
- #if isinstance (etape, str):
- # for e in self.jdc.etapes:
- # if e.nom == etape : etape=e; break
- #if etape == None : return
- definitionEtape=getattr(self.jdc.cata,nomEtape)
- #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
- ouChercher=definitionEtape
- if len(listeMC) > 1 :
-
- for mc in listeMC[0:-1]:
- mcfact=ouChercher.entites[mc]
- ouChercher=mcfact
-
- mcAccas=ouChercher.entites[listeMC[-1]]
- mcAccas.defaut=valeurs
- return 1
-
- #------------------------------------------------#
- def changeIntoDefMC(self,etape,listeMC,valeurs):
- #------------------------------------------------#
- # dans le MDD
- #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
- #definitionEtape=getattr(self.jdc.cata,nomEtape)
- print ( 'changeIntoDefMC ',etape,listeMC,valeurs)
- ouChercher=getattr(self.jdc.cata,etape.nom)
-
- #if len(listeMC) > 1 :
- # for mc in listeMC[0:-1]:
- # mcfact=ouChercher.entites[mc]
- # ouChercher=mcfact
- #mcAccas=ouChercher.entites[listeMC[-1]]
-
- for mc in listeMC :
- mcAccas=ouChercher.entites[mc]
- ouChercher=mcAccas
- if ouChercher == None : return 0
-
- if hasattr(mcAccas,'into') : oldValeurs=mcAccas.into
- else : oldValeurs=None
-
- if oldValeurs==valeurs : return 1
- mcAccas.into=valeurs
- from Noyau.N_VALIDATOR import IntoProtocol
- mcAccas.intoProto = IntoProtocol("into", into=valeurs, val_min=mcAccas.val_min, val_max=mcAccas.val_max)
- return 1
-
- #-------------------------------------------------------------#
- def deleteDefinitionMC(self,etape,listeAvant,nomDuMC):
- #-------------------------------------------------------------#
- # dans le MDD
- #print 'in deleteDefinitionMC', etape,listeAvant,nomDuMC
- if isinstance (etape, str):
- for e in self.jdc.etapes:
- if e.nom == etape : etape=e; break
- if etape == None : return
- #definitionEtape=getattr(self.jdc.cata[0],etape)
- definitionEtape=getattr(self.jdc.cata,etape)
- ouChercher=definitionEtape
- for k in listeAvant :
- ouChercher=ouChercher.entites[k]
- MCADetruire=ouChercher.entites[nomDuMC]
- ouChercher.ordre_mc.remove(nomDuMC)
- print ('remove de ', nomDuMC)
- del ouChercher.entites[nomDuMC]
- del self.dicoNouveauxMC[nomDuMC]
-
-
- #-------------------------------------------------------------#
- def ajoutDefinitionMC(self,nomEtape,listeAvant,nomDuMC,typ,**args):
- #-------------------------------------------------------------#
- # dans le MDD
- #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
- definitionEtape=getattr(self.jdc.cata,nomEtape)
- ouChercher=definitionEtape
- for k in listeAvant :
- ouChercher=ouChercher.entites[k]
- from Accas import A_SIMP
- Nouveau=A_SIMP.SIMP(typ,**args)
- Nouveau.pere=ouChercher
- Nouveau.nom=nomDuMC
- #Nouveau.ordre_mc=[]
- ouChercher.entites[nomDuMC]=Nouveau
- ouChercher.ordre_mc.append(nomDuMC)
- #print ('ajout de ', nomDuMC)
- #traceback.print_stack()
- # ajout CIST sauvegarde
- if nomDuMC in self.dicoNouveauxMC : del self.dicoNouveauxMC[nomDuMC]
- self.dicoNouveauxMC[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,typ,args)
- #print self.dicoNouveauxMC
-
- #---------------------------------------------------------------------#
- def ajoutDefinitionMCFact(self,nomEtape,listeAvant,nomDuMC,listeMC,**args):
- #---------------------------------------------------------------------#
- # dans le MDD
- print ('ajoutDefinitionMCFact', nomDuMC)
- #definitionEtape=getattr(self.jdc.cata[0],nomEtape)
- definitionEtape=getattr(self.jdc.cata,nomEtape)
- ouChercher=definitionEtape
- for k in listeAvant :
- ouChercher=ouChercher.entites[k]
- from Accas import A_SIMP
- for mc in listeMC :
- nomMC=mc[0]
- typMC=mc[1]
- argsMC=mc[2]
- nouveauMC=A_SIMP.SIMP(typMC,**argsMC)
- nouveauMC.nom=nomMC
- args[nomMC]=nouveauMC
- from Accas import A_FACT
- nouveauFact=A_FACT.FACT(**args)
- nouveauFact.pere=ouChercher
- nouveauFact.nom=nomDuMC
- from Editeur.autre_analyse_cata import traite_entite
- traite_entite(nouveauFact,[])
- ouChercher.entites[nomDuMC]=nouveauFact
- ouChercher.ordre_mc.append(nomDuMC)
- self.dicoNouveauxFact[nomDuMC]=('ajoutDefinitionMC',nomEtape,listeAvant,nomDuMC,listeMC,args)
- #print self.dicoNouveauxMC
-
- #----------------------------------------------------#
-
- #----------------------------------------------------#
- def changeIntoMCandSet(self,etape,listeMC,into,valeurs):
- #----------------------------------------------------#
- # dans le MDD et le JDC
-
- self.changeIntoDefMC(etape,listeMC,into)
-
- if isinstance (etape, str):
- for e in self.jdc.etapes:
- if e.nom == etape : etape=e; break
- if etape == None : return
-
- ouChercher = etape
- for mot in listeMC[:-1] :
- ouChercher=ouChercher.getChild(mot,restreint="oui")
- if ouChercher==None : return
- MCFils=listeMC[-1]
- monMC=ouChercher.getChild(MCFils,restreint="oui")
- if monMC== None : monMC= etape.addEntite(MCFils)
-
- monMC.definition.into=into
- monMC.valeur=valeurs
- monMC.val=valeurs
- monMC.state='changed'
- monMC.isvalid()
-
- #-------------------------------------#
- def ajoutVersionCataDsJDC(self,txt):
- #-------------------------------------#
- #if not hasattr(self.readercata.cata[0],'VERSION_CATALOGUE'): return txt
- if not hasattr(self.readercata.cata,'VERSION_CATALOGUE'): return txt
- ligneVersion="#VERSION_CATALOGUE:"+self.readercata.cata.VERSION_CATALOGUE+":FIN VERSION_CATALOGUE\n"
- texte=txt+ligneVersion
- return texte
-
- #-------------------------------------#
- def verifieVersionCataDuJDC(self,text):
- #-------------------------------------#
- memeVersion=False
- indexDeb=text.find("#VERSION_CATALOGUE:")
- indexFin=text.find(":FIN VERSION_CATALOGUE")
- if indexDeb < 0 :
- self.versionCataDuJDC="sans"
- textJDC=text
- else :
- self.versionCataDuJDC=text[indexDeb+19:indexFin]
- textJDC=text[0:indexDeb]+text[indexFin+23:-1]
-
- self.versionCata="sans"
- if hasattr(self.readercata.cata,'VERSION_CATALOGUE'): self.versionCata=self.readercata.cata.VERSION_CATALOGUE
-
- if self.versionCata==self.versionCataDuJDC : memeVersion=True
- return memeVersion,textJDC
-
- #-------------------------------#
- def traduitCatalogue(self,texte):
- #-------------------------------#
- nomTraducteur="traduit"+self.readercata.code+self.versionCataDuJDC+"To"+self.versionCata
- sys.path.append(os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)),"../Traducteur")))
- try :
- traducteur=__import__(nomTraducteur)
- monTraducteur=traducteur.MonTraducteur(texte)
- nouveauTexte=monTraducteur.traduit()
- return nouveauTexte
- except :
- return texte
-
-
-# Methodes a resorber
-# il faut mettre a jour les catalogues avec
-# TEXTE_NEW_JDC
-#
-
- #---------------------------#
- def _new_CF(self):
- #---------------------------#
- texte="CONDUITE_FORCEE();"
- return texte
-
- #---------------------------#
- def _newPSEN(self):
- #---------------------------#
- texte="DIRECTORY() ; PSSE_PARAMETERS() ; SIMULATION() ; sansnom=DISTRIBUTION() ; sansnom=DISTRIBUTION() ; CORRELATION() ;"
- #texte=""
- return texte
-
- #---------------------------#
- def _newPSEN_N1(self):
- #---------------------------#
- texte="CASE_SELECTION();N_PROCESSING_OPTIONS();CONTINGENCY_OPTIONS();CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
- #texte="CONTINGENCY_SELECTION();\nCONTINGENCY_PROCESSING(); "
- return texte
-
- #---------------------------#
- def _newZCRACKS(self):
- #---------------------------#
- texte="MAILLAGES();REMESHING();"
- return texte
-
-
- #---------------------------#
- def _newJDCCND(self):
- #---------------------------#
- extensions=tr('Fichiers Med (*.med);;''Tous les Fichiers (*)')
-
- #if self.salome == 0 :
- QMessageBox.information( self,
- tr("Fichier Med"),
- tr("Veuillez selectionner un fichier Med"))
- QSfichier = QFileDialog.getOpenFileName(self.appliEficas,
- caption='Fichier Med',
- filter=extensions)
- QSfichier=QSfichier[0]
- self.fichierMED=QSfichier
- from acquiertGroupes import getGroupes
- erreur,self.listeGroupes,self.nomMaillage,self.dicoCoord=getGroupes(self.fichierMED)
- if erreur != "" : print ("a traiter")
- texteComm="COMMENTAIRE(u'Cree - fichier : "+self.fichierMED +" - Nom Maillage : "+self.nomMaillage+"');\nPARAMETRES()\n"
- texteSources=""
- texteCond=""
- texteNoCond=""
- texteVcut=""
- texteZs=""
- for groupe in self.listeGroupes :
- if groupe[0:8]=='CURRENT_':
- texteSources +=groupe[8:]+"=SOURCE("
- texteSources +="VecteurDirecteur=(1.0,2.0,3.0,),);\n"
- if groupe[0:5]=='COND_': texteCond +=groupe[5:]+"=CONDUCTEUR();\n"
- if groupe[0:7]=='NOCOND_': texteNoCond +=groupe[7:]+"=NOCOND();\n"
- if groupe[0:5]=='VCUT_': texteVcut +='V_'+groupe[5:]+"=VCUT();\n"
- if groupe[0:3]=='ZS_': texteZs +=groupe[3:]+"=ZS();\n"
- texte=texteComm+texteSources+texteCond+texteNoCond+texteVcut+texteZs
- self.newTexteCND=texte
- self.modified=1
- return texte
-
-
-if __name__ == "__main__":
- print ('a faire')
