From 70aba88d7df8c45d9eccc6533944a53f5d9d945e Mon Sep 17 00:00:00 2001 From: "pascale.noyret" Date: Mon, 28 Jun 2021 12:08:53 +0200 Subject: [PATCH] 1ere version --- Editeur/comploader.py | 12 +- InterfaceSsIhm/eficas_go.py | 6 +- InterfaceWeb/browser.py | 319 ++++++ InterfaceWeb/compobloc.py | 57 + InterfaceWeb/compofact.py | 147 +++ InterfaceWeb/compojdc.py | 135 +++ InterfaceWeb/compomclist.py | 218 ++++ InterfaceWeb/compooper.py | 279 +++++ InterfaceWeb/compoparam.py | 155 +++ InterfaceWeb/compoproc.py | 42 + InterfaceWeb/composimp.py | 816 ++++++++++++++ InterfaceWeb/editor.py | 55 + InterfaceWeb/typeNode.py | 87 ++ Noyau/N_SIMP.py | 9 +- WebTest/{qtEficasEssai.py => genereHtml.py} | 0 editorSsIhm.py | 1118 ------------------- 16 files changed, 2329 insertions(+), 1126 deletions(-) create mode 100644 InterfaceWeb/browser.py create mode 100644 InterfaceWeb/compobloc.py create mode 100644 InterfaceWeb/compofact.py create mode 100644 InterfaceWeb/compojdc.py create mode 100644 InterfaceWeb/compomclist.py create mode 100644 InterfaceWeb/compooper.py create mode 100644 InterfaceWeb/compoparam.py create mode 100644 InterfaceWeb/compoproc.py create mode 100644 InterfaceWeb/composimp.py create mode 100755 InterfaceWeb/editor.py create mode 100644 InterfaceWeb/typeNode.py rename WebTest/{qtEficasEssai.py => genereHtml.py} (100%) delete mode 100755 editorSsIhm.py diff --git a/Editeur/comploader.py b/Editeur/comploader.py index c802862c..fc795ded 100644 --- a/Editeur/comploader.py +++ b/Editeur/comploader.py @@ -45,9 +45,14 @@ def chargerComposants(Ihm="QT"): 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]) @@ -70,6 +75,8 @@ def gettreeitem(object): # On cherche ensuite dans les composants (plugins) try: + print (object.__class__) + print (composants) itemtype= composants[object.__class__] return itemtype except: @@ -90,5 +97,6 @@ def makeObjecttreeitem(appliEficas,labeltext, object, setFunction=None): Cette fonction permet de construire et de retourner un objet de type item associe a l'object passe en argument. """ + print (object) c = gettreeitem(object) return c(appliEficas,labeltext, object, setFunction) diff --git a/InterfaceSsIhm/eficas_go.py b/InterfaceSsIhm/eficas_go.py index 9609025c..c936fde5 100755 --- a/InterfaceSsIhm/eficas_go.py +++ b/InterfaceSsIhm/eficas_go.py @@ -32,10 +32,12 @@ repIni = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file 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") @@ -112,8 +114,8 @@ def lanceEficas_Web(code=None): 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): diff --git a/InterfaceWeb/browser.py b/InterfaceWeb/browser.py new file mode 100644 index 00000000..a6a7833f --- /dev/null +++ b/InterfaceWeb/browser.py @@ -0,0 +1,319 @@ +# -*- 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): + #--------------------- + diff --git a/InterfaceWeb/compobloc.py b/InterfaceWeb/compobloc.py new file mode 100644 index 00000000..140f7b42 --- /dev/null +++ b/InterfaceWeb/compobloc.py @@ -0,0 +1,57 @@ +# -*- 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 diff --git a/InterfaceWeb/compofact.py b/InterfaceWeb/compofact.py new file mode 100644 index 00000000..4e7ae086 --- /dev/null +++ b/InterfaceWeb/compofact.py @@ -0,0 +1,147 @@ +# -*- 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 diff --git a/InterfaceWeb/compojdc.py b/InterfaceWeb/compojdc.py new file mode 100644 index 00000000..3c9e5a39 --- /dev/null +++ b/InterfaceWeb/compojdc.py @@ -0,0 +1,135 @@ +# -*- 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 diff --git a/InterfaceWeb/compomclist.py b/InterfaceWeb/compomclist.py new file mode 100644 index 00000000..5d74def0 --- /dev/null +++ b/InterfaceWeb/compomclist.py @@ -0,0 +1,218 @@ +# -*- 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) diff --git a/InterfaceWeb/compooper.py b/InterfaceWeb/compooper.py new file mode 100644 index 00000000..59388ec2 --- /dev/null +++ b/InterfaceWeb/compooper.py @@ -0,0 +1,279 @@ +#-*- 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 diff --git a/InterfaceWeb/compoparam.py b/InterfaceWeb/compoparam.py new file mode 100644 index 00000000..ca9b1c02 --- /dev/null +++ b/InterfaceWeb/compoparam.py @@ -0,0 +1,155 @@ +# -*- 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 diff --git a/InterfaceWeb/compoproc.py b/InterfaceWeb/compoproc.py new file mode 100644 index 00000000..767c0f6b --- /dev/null +++ b/InterfaceWeb/compoproc.py @@ -0,0 +1,42 @@ +# -*- 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 diff --git a/InterfaceWeb/composimp.py b/InterfaceWeb/composimp.py new file mode 100644 index 00000000..8b047566 --- /dev/null +++ b/InterfaceWeb/composimp.py @@ -0,0 +1,816 @@ +# -*- 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 diff --git a/InterfaceWeb/editor.py b/InterfaceWeb/editor.py new file mode 100755 index 00000000..eaaa2f33 --- /dev/null +++ b/InterfaceWeb/editor.py @@ -0,0 +1,55 @@ +# -*- 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 ) + + diff --git a/InterfaceWeb/typeNode.py b/InterfaceWeb/typeNode.py new file mode 100644 index 00000000..ca99c73e --- /dev/null +++ b/InterfaceWeb/typeNode.py @@ -0,0 +1,87 @@ +# -*- 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") diff --git a/Noyau/N_SIMP.py b/Noyau/N_SIMP.py index 80f2d0c7..fdc3148d 100644 --- a/Noyau/N_SIMP.py +++ b/Noyau/N_SIMP.py @@ -51,7 +51,7 @@ class SIMP(N_ENTITE.ENTITE): 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 @@ -127,14 +127,15 @@ class SIMP(N_ENTITE.ENTITE): 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) : diff --git a/WebTest/qtEficasEssai.py b/WebTest/genereHtml.py similarity index 100% rename from WebTest/qtEficasEssai.py rename to WebTest/genereHtml.py diff --git a/editorSsIhm.py b/editorSsIhm.py deleted file mode 100755 index 7c12bdda..00000000 --- a/editorSsIhm.py +++ /dev/null @@ -1,1118 +0,0 @@ -# -*- 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') -- 2.39.2