from Noyau import N_GEOM
from Noyau import N_FONCTION
from Noyau import N_CO
+from Noyau import N_UserASSD
# On ajoute la classe ASSD dans l'heritage multiple pour recreer
# une hierarchie d'heritage identique a celle de Noyau
class ASSD(I_ASSD.ASSD,N_ASSD.ASSD):pass
#class LASSD(I_LASSD.LASSD,N_LASSD.LASSD):pass
class LASSD(I_LASSD.LASSD):pass
+class UserASSD(N_UserASSD.UserASSD,ASSD): pass
class assd(N_ASSD.assd,I_ASSD.assd,ASSD):pass
class geom(N_GEOM.geom,I_ASSD.geom,ASSD):pass
class CO(N_CO.CO,I_ASSD.CO,ASSD):pass
-class UserASSD(ASSD):
- def __init__(self, nom):
- ASSD.__init__(self)
- self.setName(nom)
if not self.cata.modeleMetier : return
if self.nom == 'Consigne' : return None
trouve = False
- listeArg=[]
if debug : print self.perePyxb.objPyxb.orderedContent()
if debug : print (map(lambda o:o.value, self.perePyxb.objPyxb.orderedContent()))
def o_register(self,sd):
return self.jdc_pere.o_register(sd)
- def NommerSdprod(self,sd,sdnom,restrict='non'):
+ def nommerSDProd(self,sd,sdnom,restrict='non'):
"""
Nomme la SD apres avoir verifie que le nommage est possible : nom
non utilise
Si le nom est deja utilise, leve une exception
Met le concept cree dans le contexe global g_context
"""
- #print "NommerSdprod",sd,sdnom,restrict
+ #print "nommerSDProd",sd,sdnom,restrict
if self.prefix_include:
if sdnom != self.prefix_include:sdnom=self.prefix_include+sdnom
sdnom=sd.id[2:]
pass
- o=self.sds_dict.get(sdnom,None)
+ o=self.sdsDict.get(sdnom,None)
if isinstance(o,ASSD):
raise AsException(tr("Nom de concept deja defini : %s" ,sdnom))
# ATTENTION : Il ne faut pas ajouter sd dans sds car il s y trouve deja.
# Ajoute a la creation (appel de regSD).
- self.sds_dict[sdnom]=sd
+ self.sdsDict[sdnom]=sd
sd.nom=sdnom
# En plus si restrict vaut 'non', on insere le concept dans le contexte du JDC
elif debug:
print ("Unable to load Eficas translator!")
- global code_translator
if debug : print ('translatorFichier :' ,translatorFichier)
if translatorFichier != None :
if (code_translator.load(translatorFichier)) and debug:
self.definition=definition
self.nom=nom
self.parent = parent
- # GETVAL affecte la valeur par defaut si necessaire
- self.valeur=self.GETVAL(self.val)
+ # getValeurEffective affecte la valeur par defaut si necessaire
+ self.valeur=self.getValeurEffective(self.val)
if parent :
self.jdc = self.parent.jdc
self.niveau = self.parent.niveau
class ASSD:
def __repr__(self):
- return tr("concept %(inst_name)s de type %(class_name)s", \
- {'inst_name': self.getName(), \
- 'class_name': self.__class__.__name__})
+ return "concept " + self.getName() + " type " + self.__class__.__name__
def __str__(self):
return self.getName() or "<None>"
- #def __del__(self):
- # print "__del__",self
class assd(ASSD):
def __convert__(cls,valeur):
class GEOM(ASSD):
def __convert__(cls,valeur):
return valeur
- __convert__=classmethod(__convert__)
+ __convert__= classmethod(__convert__)
class geom(GEOM):
pass
from Extensions.eficas_exception import EficasException
# Objet re pour controler les identificateurs Python
-concept_re=re.compile(r'[a-zA-Z_]\w*$')
+conceptRE=re.compile(r'[a-zA-Z_]\w*$')
# import rajoute suite a l'ajout de buildSd --> a resorber
import traceback
- 1 dans le cas contraire
"""
# Le nom d'un concept doit etre un identificateur Python (toujours vrai ?)
- if not concept_re.match(nom):
+ if not conceptRE.match(nom):
return 0, tr("Un nom de concept doit etre un identificateur Python")
# pour eviter que le nom du concept soit le nom de la classe --> souci pour utiliser le concept
#print ("getContexteJdc",self,self.nom, text)
# On recupere l'etape courante
step=CONTEXT.getCurrentStep()
+ self.text_included_converted=0
#try:
if 1 :
# on essaie de creer un objet JDC auxiliaire avec un contexte initial
old_recorded_units=old_recorded_units,**args)
j.analyse()
+ if not j.cr.estvide(): self.text_included_converted=0
+ else : self.text_included_converted=1
+ self.text_included_error=str(j.cr)
# On recupere les etapes internes (pour validation)
self.etapes=j.etapes
self.jdc_aux=j
# On remplit le dictionnaire des concepts produits inclus
# en retirant les concepts presents dans le contexte initial
- # On ajoute egalement le concept produit dans le sds_dict du parent
+ # On ajoute egalement le concept produit dans le sdsDict du parent
# sans verification car on est sur (verification integree) que
# le nommage est possible
self.g_context.clear()
for k,v in j_context.items():
if (not k in context_ini) or (context_ini[k] != v):
self.g_context[k]=v
- self.parent.sds_dict[k]=v
+ self.parent.sdsDict[k]=v
#Ce traitement n'est realise que dans les cas suivants:
# - si convert n'a pas pu convertir le jeu de commandes
self.jdc_aux.cr=self.jdc_aux.CR()
# On remplit le dictionnaire des concepts produits inclus
# en retirant les concepts presents dans le contexte initial
- # On ajoute egalement le concept produit dans le sds_dict du parent
+ # On ajoute egalement le concept produit dans le sdsDict du parent
# sans verification car on est sur (verification integree) que
# le nommage est possible
j_context=self.jdc_aux.getContexteAvant(None)
for k,v in j_context.items():
if not k in context_ini or context_ini[k] != v:
self.g_context[k]=v
- self.parent.sds_dict[k]=v
+ self.parent.sdsDict[k]=v
# On recupere le contexte courant
self.current_context=self.jdc_aux.current_context
self.index_etape_courante=self.jdc_aux.index_etape_courante
import Noyau
from . import CONNECTOR
+import re
+conceptRE=re.compile(r'[a-zA-Z_]\w*$')
class OBJECT:
from Noyau.N_CO import CO
#def __del__(self):
# print "__del__",self
+ def nommeSd(self):
+ # surcharge dans I_ETAPE.py
+ if ( nom in dir(self.jdc.cata)) : return (0, nom + tr("mot reserve"))
+ if not conceptRE.match(nom):
+ return 0, tr("Un nom de concept doit etre un identificateur Python")
+ self.initModif()
+ #self.getSdProd()
+ #self.sd.nom = nom
+ #self.sdnom=nom
+ #self.parent.updateConceptAfterEtape(self,self.sd)
+ #self.finModif()
+ #return 1, tr("Nommage du concept effectue")
+
+
+
+
+
class ErrorObj(OBJECT):pass
Inputs :
- sd=concept detruit
"""
+ print ('iiiiiiiiiiiiiiiiiiiii')
+ print (self)
+ import traceback
+ traceback.print_stack()
for child in self.mcListe :
child.deleteConcept(sd)
def handleCollapsedItem(self,item):
#----------------------------------
- #print ("dans CollapsedItem", self.inhibeExpand )
+ print ("dans CollapsedItem", self.inhibeExpand )
if self.inhibeExpand == True : return
# On traite le cas de l item non selectionne
self.itemCourant = item
+ itemParent = item
while not (hasattr (itemParent,'getPanel')) : itemParent=itemParent.treeParent
if self.tree.node_selected != itemParent :
item.setExpanded(False)
return
- itemParent = item
item.setPlie()
item.plieToutEtReaffiche()
item.select()
if pos == 'before': index = index
elif pos == 'after' : index = index +1
else:
- print(six.text_type(pos), tr(" n'est pas un index valide pour appendBrother"))
+ print(pos, tr(" n'est pas un index valide pour appendBrother"))
return 0
return self.treeParent.appendChild(name,pos=index,plier=plier)
class BLOCTreeItem(compofact.FACTTreeItem):
itemNode=Node
- #def get_objet(self,name) :
- # for v in self.object.mcListe:
- # if v.nom == name : return v
- # return None
-
def isCopiable(self):
return 0
debComm=self.item.getText()
self.setText(1,tr(debComm))
-
class COMMTreeItem(Objecttreeitem.ObjectTreeItem):
itemNode=Node
class Node(browser.JDCNode,typeNode.PopUpMenuNodePartiel):
- def getPanelGroupe(self,parentQt,commande,insertIn=-1):
- # est-ce que ce n est pas toujours le getPanelGroupe de compomclist qui est utilisee
+ def getPanelGroupe(self,parentQt,commande):
+ # ----------------------------------------
maDefinition=self.item.get_definition()
monObjet=self.item.object
monNom=self.item.nom
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,insertIn)
+ 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,insertIn)
+ 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,insertIn)
+ widget=MonWidgetFact(self,self.editor,parentQt,maDefinition,monObjet,self.niveau,maCommande)
return widget
def createPopUpMenu(self):
+ # ------------------------
typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
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
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"
+ # ----------------
+ if self.object.isValid() : return "ast-green-los"
+ elif self.object.isOblig(): return "ast-red-los"
+ else : return "ast-yel-los"
#PNPN ????
#def keys(self):
# return keys
def getSubList(self):
+ # ----------------
"""
Reactualise la liste des items fils stockes dans self.sublist
"""
def createPopUpMenu(self):
typeNode.PopUpMenuNode.createPopUpMenu(self)
-# if ("AFFE_CARA_ELEM" in self.item.getGenealogie()) and self.editor.salome:
-# from PyQt5.QtWidgets import QAction
-# self.ViewElt = QAction(tr('View3D'),self.tree)
-# self.ViewElt.triggered.connect(self.view3D)
-# self.ViewElt.setStatusTip(tr("affiche dans Geom les elements de structure"))
-# self.menu.addAction(self.ViewElt)
-# if self.item.isValid() :
-# self.ViewElt.setEnabled(1)
-# else:
-# self.ViewElt.setEnabled(0)
# def view3D(self) :
# from Editeur import TroisDPal
def createPopUpMenu(self):
typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
- def getPanelGroupe(self,parentQt,commande,insertIn=-1):
+ def getPanelGroupe(self,parentQt,commande):
maDefinition=self.item.get_definition()
monObjet=self.item.object
monNom=self.item.nom
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,insertIn)
+ 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,insertIn)
+ 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,insertIn)
+ 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)
from InterfaceQT4.monWidgetSDCOInto import MonWidgetSDCOInto
widget=MonWidgetSDCOInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif self.item.waitAssd():
- if len(self.item.getSdAvantDuBonType()) == 0 :
+ if self.item.waitUserAssdEnCreation() :
+ from InterfaceQT4.monWidgetCreeUserAssd import MonWidgetCreeUserAssd
+ widget=MonWidgetCreeUserAssd(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif len(self.item.getSdAvantDuBonType()) == 0 :
from InterfaceQT4.monWidgetVide import MonWidgetVide
widget=MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
elif len(self.item.getSdAvantDuBonType()) < 4 :
return text
- def setValeurCo(self,nom_co):
+ def setValeurCo(self,nomCo):
"""
Affecte au MCS pointe par self l'objet de type CO et de nom nom_co
"""
- ret = self.object.setValeurCo(nom_co)
+ ret = self.object.setValeurCo(nomCo)
#print "setValeurCo",ret
return ret
le MCS pointe par self et du type requis par ce MCS
"""
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
import types,sys,os, re
import subprocess
import traceback
-import six
from PyQt5.QtWidgets import QWidget, QMessageBox, QFileDialog, QApplication, QSplitter, QLabel
if fn == None : return (0, None)
if fn== '' : return (0, None)
- ulfile = os.path.abspath(six.text_type(fn))
+ ulfile = os.path.abspath(fn)
self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
- fn = six.text_type(QDir.toNativeSeparators(fn))
+ fn = QDir.toNativeSeparators(fn)
self.fichierComplet = os.path.splitext(fn)[0]+extension
if fn == None : return (0, None)
if fn== '' : return (0, None)
- ulfile = os.path.abspath(six.text_type(fn))
+ ulfile = os.path.abspath(fn)
self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
- fn = six.text_type(QDir.toNativeSeparators(fn))
+ fn = QDir.toNativeSeparators(fn)
newName = fn
if not fn : return (0, " ")
fn=fn[0]
- ulfile = os.path.abspath(six.text_type(fn))
+ ulfile = os.path.abspath(fn)
self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
# On utilise le convertisseur defini par format_fichier
# ajoute une etape de JdC a partir d un texte
CONTEXT.setCurrentStep(etape)
etape.buildIncludeEtape(texte)
+ if not (etape.text_included_converted) :
+ QMessageBox.information( self,
+ tr("Impossible d importer le texte"),
+ etape.text_included_error)
+
self.tree.racine.buildChildren()
#-----------------------------------#
if self.code == "PSEN" : texte = self._newPSEN()
if self.code == "PSEN_N1" : texte = self._newPSEN_N1()
- #if hasattr(self.readercata.cata[0],'TEXTE_NEW_JDC') : texte=self.readercata.cata[0].TEXTE_NEW_JDC
if hasattr(self.readercata.cata,'TEXTE_NEW_JDC') : texte=self.readercata.cata.TEXTE_NEW_JDC
- #jdc=self.readercata.cata[0].JdC( procedure =texte,
- #print (self.readercata.cata)
jdc=self.readercata.cata.JdC( procedure =texte,
appliEficas=self,
cata=self.readercata.cata,
if units is not None:
jdc.recorded_units=units
jdc.old_recorded_units=units
- ## PNPN est ce que la ligne suivante est bien utile ?
- # elle positionne le contexte
+ # 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 ?
- if self.format == 'xml' : return jdc
- if texte == "" :
- jdc.editor=self
- jdc.analyse()
+ jdc.editor=self
return jdc
#--------------------------------#
def viewJdcSource(self):
#-----------------------#
if self.fichier == None : return
- f=open(self.fichier,'r')
- texteSource=f.read()
- f.close()
- self._viewText(texteSource, "JDC_SOURCE")
+ 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):
return 0
#-----------------------------------------------------------#
- def getTextJDC(self,format,pourRun=0,formatLigne="beautifie"):
+ 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.format
if format in generator.plugins:
# Le generateur existe on l'utilise
import sys,os
-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")
+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")
-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)
-
-def getEficasSsIhm(code=None,fichier=None,ssCode=None,multi=False,langue='en',versionCode=None, fichierCata=None):
- if fichierCata != None : fichierCata = os.path.abspath(fichierCata)
- from InterfaceQT4.qtEficasSsIhm import AppliSsIhm
- Eficas=AppliSsIhm(code=code,salome=0,ssCode=ssCode,multi=multi,langue=langue,versionCode=versionCode, fichierCata=fichierCata)
- from Editeur import session
- options=session.parse(['ssIhm','-k',code,'-v',versionCode])
- return Eficas
+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)
def lanceEficas(code=None,fichier=None,ssCode=None,multi=False,langue='en'):
+#-------------------------------------------------------------------------
"""
- Lance l'appli EFICAS
+ Lance l'appli EFICAS avec Ihm
"""
- from PyQt5.QtWidgets import QApplication
- # Analyse des arguments de la ligne de commande
+ try :
+ from PyQt5.QtWidgets import QApplication
+ except :
+ print('Please, set qt environment')
+ return
+
from Editeur import session
- options=session.parse(sys.argv)
- if options.code!= None : code=options.code
- if options.ssCode!= None : ssCode=options.ssCode
+ options = session.parse(sys.argv)
+ if options.code != None : code=options.code
+ if options.ssCode != None : ssCode=options.ssCode
from InterfaceQT4.qtEficas import Appli
app = QApplication(sys.argv)
- #import cProfile, pstats, StringIO
- #pr = cProfile.Profile()
- #pr.enable()
-
Eficas=Appli(code=code,salome=0,ssCode=ssCode,multi=multi,langue=langue)
- #pr.disable()
- #s = StringIO.StringIO()
- #sortby = 'cumulative'
- #ps = pstats.Stats(pr, stream=s).sort_stats(sortby)
- #ps.print_stats()
- #print (s.getValue())
-
Eficas.show()
res=app.exec_()
sys.exit(res)
+def getEficasSsIhm(code=None,fichier=None,ssCode=None,multi=False,langue='en',versionCode=None, fichierCata=None):
+#----------------------------------------------------------------------------------------------------------------
+ """
+ Lance l'appli EFICAS sans Ihm
+ """
+ from Editeur import session
+ options = session.parse(sys.argv)
+ if options.code != None : code=options.code
+ if options.ssCode != None : ssCode=options.ssCode
+ if options.ssCode != None : ssCode=options.ssCode
+ if fichierCata != None : fichierCata = os.path.abspath(fichierCata)
+
+ from InterfaceQT4.qtEficasSsIhm import AppliSsIhm
+ options=session.parse(['ssIhm','-k',code,'-v',versionCode])
+ Eficas=AppliSsIhm(code=code,salome=0,ssCode=ssCode,multi=multi,langue=langue,versionCode=versionCode, fichierCata=fichierCata)
+ return Eficas
+
def genereXSD(code=None,fichier=None,ssCode=None,multi=False,langue='en',debug=True):
from Editeur import session
- options=session.parse(sys.argv)
- if options.code!= None : code=options.code
+ options = session.parse(sys.argv)
+ if options.code != None : code=options.code
if options.ssCode!= None : ssCode=options.ssCode
if options.cata == None :
print ('Use -c cata_name.py')
def lanceEficas_ssIhm(code=None,fichier=None,ssCode=None,version=None,debug=False,langue='en'):
"""
- Lance l'appli EFICAS pour trouver les noms des groupes
+ Lance l'appli EFICAS SsIhm
"""
# Analyse des arguments de la ligne de commande
from Editeur import session
parameters=getJdcParameters(texte,macro)
return parameters
-#def getEficasSsIhm(code='Adao',versionCode='V0'):
-# from .qtEficasSsIhm import AppliSsIhm
-# Eficas=AppliSsIhm(code=code,ssCode=None,salome=0)
-# return Eficas
def getJdcParameters(jdc,macro):
"""
import types,os,re,sys
import traceback
-import six
import inspect
from PyQt5.QtWidgets import QMessageBox, QFileDialog , QMenu, QPushButton, QTreeView ,QListView, QAbstractItemView
fichier=fichier[0]
if not(fichier == ""):
- ulfile = os.path.abspath(six.text_type(fichier))
+ ulfile = os.path.abspath(fichier)
self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
self.lineEditVal.setText(fichier)
self.editor.afficheCommentaire(tr("Fichier selectionne"))
options = QFileDialog.ShowDirsOnly)
if not (directory == "") :
- absdir = os.path.abspath(six.text_type(directory))
+ absdir = os.path.abspath(directory)
self.appliEficas.maConfiguration.savedir = os.path.dirname(absdir)
self.lineEditVal.setText(directory)
self.LEvaleurPressed()
from __future__ import absolute_import
try :
from builtins import str
- from builtins import range
from builtins import object
except : pass
import traceback
-import six
-from six.moves import range
from PyQt5.QtWidgets import QLineEdit, QLabel, QFileDialog, QMessageBox
from PyQt5.QtCore import QEvent, Qt, QTimer
from PyQt5.QtGui import QIcon, QPalette
fn=fn[0]
if fn == None : return
if fn == "" : return
- ulfile = os.path.abspath(six.text_type(fn))
+ ulfile = os.path.abspath(fn)
self.editor.maConfiguration.savedir=os.path.split(ulfile)[0]
from .monSelectVal import MonSelectVal
filtre=str(self.LEFiltre.text())
for cb in self.listeCbRouge:
palette = QPalette(Qt.red)
- palette.setColor(QPalette.WindowText,Qt.black)
- cb.setPalette(palette)
+ palette.setColor(QPalette.WindowText,Qt.black)
+ cb.setPalette(palette)
t=cb.text()
cb.setText(t)
self.LEFiltre.setText("")
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2017 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
+
+from __future__ import absolute_import
+try :
+ from builtins import str
+ from builtins import object
+except : pass
+
+import types,os
+import traceback
+
+
+from PyQt5.QtWidgets import QLineEdit, QLabel, QFileDialog, QMessageBox
+from PyQt5.QtCore import QEvent, Qt, QTimer
+from PyQt5.QtGui import QIcon, QPalette
+
+from Extensions.i18n import tr
+from InterfaceQT4.monViewTexte import ViewText
+
+
+# ---------------------- #
+class LECustom(QLineEdit):
+# ---------------------- #
+ def __init__(self,parent,parentQt,i):
+ """
+ Constructor
+ """
+ QLineEdit.__init__(self,parent)
+
+ self.parentQt=parentQt
+ self.num=i
+ self.dansUnTuple=False
+ self.numDsLaListe=-1
+ self.parentTuple=None
+ self.valeur=None
+ self.editingFinished.connect(self.editFinished)
+ self.textEdited.connect(self.edited)
+ self.parentWidgetPlusieurs = parent
+ self.oldValeur=None
+
+ def edited(self,text):
+ #print ('dans textEdited')
+ self.parentQt.changeUnLineEdit=True
+
+ def focusInEvent(self,event):
+ #print ("dans focusInEvent de LECustom")
+ self.parentQt.aEuLeFocus=True
+ self.parentQt.numLineEditEnCours=self.num
+ self.parentQt.textSelected=self.text()
+ self.setStyleSheet("border: 2px solid gray")
+ self.oldValeur=self.text()
+ QLineEdit.focusInEvent(self,event)
+
+ def focusOutEvent(self,event):
+ #print ("dans focusOutEvent de LECustom")
+ self.setStyleSheet("border: 0px")
+ if self.dansUnTuple : self.setStyleSheet("background:rgb(235,235,235); border: 0px;")
+ elif self.num % 2 == 1 : self.setStyleSheet("background:rgb(210,210,210)")
+ else : self.setStyleSheet("background:rgb(235,235,235)")
+ if (self.oldValeur == self.text()): QLineEdit.focusOutEvent(self,event);return
+ self.litValeur()
+ QLineEdit.focusOutEvent(self,event)
+
+ def editFinished(self):
+ #print ("dans editFinished de LECustom")
+ if (self.oldValeur == self.text()): return
+ self.litValeur()
+
+ def litValeur(self):
+ #print ("dans litValeur de LECustom")
+ if (self.oldValeur == self.text()): return
+ self.oldValeur = self.text()
+ val=str(self.text())
+
+ # on verifie les ','
+ lval=val.split(',')
+ if len (lval) == 2 :
+ msgBox=QMessageBox()
+ msgBox.setText("separator ',' ")
+ msgBox.setInformativeText("Do you want to enter " + '.'.join(lval) + "?")
+ msgBox.setStandardButtons( QMessageBox.Ok | QMessageBox.Cancel)
+ msgBox.setDefaultButton(QMessageBox.Ok)
+ ret = msgBox.exec_()
+ if ret != 1024 : self.setText("")
+ else : self.setText('.'.join(lval))
+ self.litValeur()
+ if len (lval) > 2 :
+ self.setText("")
+ self.litValeur()
+ if str(val)=="" or val==None : self.valeur=None; return
+ try : valeur=eval(val,{})
+ except :
+ try :
+ d=self.parentQt.parentQt.objSimp.jdc.getContexteAvant(self.parentQt.objSimp. etape)
+ valeur=eval(val,d)
+ except :
+ valeur=val
+ self.valeur=valeur
+ #print ('self.valeur', self.valeur)
+
+
+ def clean(self):
+ self.setText("")
+
+ def getValeur(self):
+ #return self.text()
+ return self.valeur
+
+ def setValeur(self,valeur):
+ self.setText(valeur)
+
+
+
+# --------------------------- #
+class LECustomTuple(LECustom):
+# --------------------------- #
+ def __init__(self,parent):
+ # index sera mis a jour par TupleCustom
+ parentQt=parent.parent().parent().parent()
+ LECustom. __init__(self,parent,parentQt,0)
+ #print (dir(self))
+
+# ---------------------------- #
+class MonLabelListeClic(QLabel):
+# ---------------------------- #
+ def __init__(self,parent):
+ QLabel.__init__(self,parent)
+ self.parent=parent
+
+ def event(self,event) :
+ if event.type() == QEvent.MouseButtonRelease:
+ self.texte=self.text()
+ self.parent.traiteClicSurLabelListe(self.texte)
+ return QLabel.event(self,event)
+
+
+
+
+# ------------- #
+class GereListe(object):
+# ------------- #
+
+ def __init__(self):
+ self.connecterSignaux()
+
+
+ def connecterSignaux(self):
+ if hasattr(self,'RBHaut'):
+ self.RBHaut.clicked.connect(self.hautPushed)
+ self.RBBas.clicked.connect(self.basPushed)
+ self.RBMoins.clicked.connect(self.moinsPushed)
+ self.RBPlus.clicked.connect(self.plusPushed)
+ self.RBVoisListe.clicked.connect(self.voisListePushed)
+ if hasattr(self,'PBAlpha'):
+ self.PBCata.clicked.connect(self.cataPushed)
+ self.PBAlpha.clicked.connect(self.alphaPushed)
+ self.PBFind.clicked.connect(self.findPushed)
+ self.LEFiltre.returnPressed.connect(self.LEFiltreReturnPressed)
+ if hasattr(self, 'PBValideFeuille'):
+ self.PBValideFeuille.clicked.connect(self.changeValeur)
+
+ def filtreListe(self):
+ l=[]
+ if self.filtre != "" :
+ for i in self.listeAAfficher :
+ if i.find(self.filtre) == 0 :l.append(i)
+ self.listeAAfficher=l
+ if self.alpha : self.listeAAfficher.sort()
+
+ def LEFiltreReturnPressed(self):
+ self.filtre= self.LEFiltre.text()
+ self.prepareListeResultatFiltre()
+
+ def findPushed(self):
+ self.filtre= self.LEFiltre.text()
+ self.prepareListeResultatFiltre()
+
+ def alphaPushed(self):
+ #print "alphaPushed" ,self.alpha
+ if self.alpha == 1 : return
+ self.alpha=1
+ self.prepareListeResultat()
+
+ def cataPushed(self):
+ if self.alpha == 0 : return
+ self.alpha=0
+ self.prepareListeResultat()
+
+ def hautPushed(self):
+ if self.numLineEditEnCours == 1 : return
+ else : numEchange=self.numLineEditEnCours-1
+ self.echange(self.numLineEditEnCours,numEchange)
+ self.LineEditEnCours.setFocus(True)
+ self.scrollArea.ensureWidgetVisible(self.LineEditEnCours)
+
+
+ def basPushed(self):
+ if self.numLineEditEnCours == self.indexDernierLabel : return
+ else : numEchange=self.numLineEditEnCours+1
+ self.echange(self.numLineEditEnCours,numEchange)
+ self.LineEditEnCours.setFocus(True)
+ self.scrollArea.ensureWidgetVisible(self.LineEditEnCours)
+
+ def echange(self,num1,num2):
+ # on donne le focus au a celui ou on a bouge
+ # par convention le 2
+ nomLineEdit=self.nomLine+str(num1)
+ #print nomLineEdit
+ courant=getattr(self,nomLineEdit)
+ valeurAGarder=courant.text()
+ nomLineEdit2=self.nomLine+str(num2)
+ #print nomLineEdit2
+ courant2=getattr(self,nomLineEdit2)
+ courant.setText(courant2.text())
+ courant2.setText(valeurAGarder)
+ self.changeValeur(changeDePlace=False)
+ self.numLineEditEnCours=num2
+ self.LineEditEnCours=courant2
+ self.LineEditEnCours.setFocus(True)
+
+ def moinsPushed(self):
+ # on supprime le dernier
+ if self.numLineEditEnCours == 0 : return
+ if self.indexDernierLabel == 0 : return
+ if self.numLineEditEnCours==self.indexDernierLabel :
+ nomLineEdit=self.nomLine+str(self.indexDernierLabel)
+ courant=getattr(self,nomLineEdit)
+ courant.clean()
+ else :
+ for i in range (self.numLineEditEnCours, self.indexDernierLabel):
+ aRemonter=i+1
+ nomLineEdit=self.nomLine+str(aRemonter)
+ courant=getattr(self,nomLineEdit)
+ valeurARemonter=courant.getValeur()
+ nomLineEdit=self.nomLine+str(i)
+ courant=getattr(self,nomLineEdit)
+ if valeurARemonter != None : courant.setValeur(valeurARemonter)
+ else : courant.clean()
+ nomLineEdit=self.nomLine+str(self.indexDernierLabel)
+ courant=getattr(self,nomLineEdit)
+ courant.clean()
+ self.changeValeur(changeDePlace=False,oblige=True)
+ self.setValide()
+
+ def plusPushed(self):
+ if self.indexDernierLabel == self.monSimpDef.max:
+ if len(self.listeValeursCourantes) < self.monSimpDef.max : self.chercheLigneVide()
+ else : self.editor.afficheInfos('nb max de valeurs : '+str(self.monSimpDef.max)+' atteint',Qt.red)
+ return
+ self.ajoutLineEdit()
+ self.descendLesLignes()
+ self.chercheLigneVide()
+ QTimer.singleShot(1, self.rendVisibleLigne)
+
+ def chercheLigneVide(self):
+ for i in range(self.indexDernierLabel) :
+ nomLineEdit=self.nomLine+str(i+1)
+ courant=getattr(self,nomLineEdit)
+ valeur=courant.getValeur()
+ if valeur=="" :
+ courant.setFocus(True)
+ self.estVisible=courant
+ return
+
+
+ def descendLesLignes(self):
+ if self.numLineEditEnCours==self.indexDernierLabel : return
+ nomLineEdit=self.nomLine+str(self.numLineEditEnCours+1)
+ courant=getattr(self,nomLineEdit)
+ valeurADescendre=courant.getValeur()
+ courant.clean()
+ for i in range (self.numLineEditEnCours+1, self.indexDernierLabel):
+ aDescendre=i+1
+ nomLineEdit=self.nomLine+str(aDescendre)
+ courant=getattr(self,nomLineEdit)
+ valeurAGarder=courant.getValeur()
+ courant.setValeur(valeurADescendre)
+ valeurADescendre=valeurAGarder
+ self.changeValeur(changeDePlace=False)
+ if hasattr (self, 'LineEditEnCours') :self.scrollArea.ensureWidgetVisible(self.LineEditEnCours)
+
+ def voisListePushed(self):
+ texteValeurs=""
+ for v in self.node.item.getListeValeurs():
+ texteValeurs+=str(v)+", "
+ entete="Valeurs pour "+self.nom
+ f=ViewText(self,self.editor,entete,texteValeurs[0:-2])
+ f.show()
+
+
+ def selectInFile(self):
+ init=str( self.editor.maConfiguration.savedir)
+ fn = QFileDialog.getOpenFileName(self.node.appliEficas,
+ tr("Fichier de donnees"),
+ init,
+ tr('Tous les Fichiers (*)',))
+ fn=fn[0]
+ if fn == None : return
+ if fn == "" : return
+ ulfile = os.path.abspath(fn)
+ self.editor.maConfiguration.savedir=os.path.split(ulfile)[0]
+
+ from .monSelectVal import MonSelectVal
+ MonSelectVal(file=fn,parent=self).show()
+
+ def noircirResultatFiltre(self):
+ filtre=str(self.LEFiltre.text())
+ for cb in self.listeCbRouge:
+ palette = QPalette(Qt.red)
+ palette.setColor(QPalette.WindowText,Qt.black)
+ cb.setPalette(palette)
+ t=cb.text()
+ cb.setText(t)
+ self.LEFiltre.setText("")
+ self.listeCbRouge = []
+
+
+# ----------- #
+class GerePlie(object):
+# ----------- #
+
+ def gereIconePlier(self):
+ if not(hasattr(self,'BFermeListe')) : return
+ self.editor.listeDesListesOuvertes.add(self.node.item)
+ repIcon=self.node.editor.appliEficas.repIcon
+ if not (self.editor.afficheListesPliees):
+ fichier=os.path.join(repIcon, 'empty.png')
+ icon = QIcon(fichier)
+ self.BFermeListe.setIcon(icon)
+ return
+ fichier=os.path.join(repIcon, 'minusnode.png')
+ icon = QIcon(fichier)
+ self.BFermeListe.setIcon(icon)
+ self.BFermeListe.clicked.connect( self.selectWidgetPlie)
+
+ def selectWidgetPlie(self):
+ self.editor.listeDesListesOuvertes.remove(self.node.item)
+ self.reaffichePourDeplier()
+
+
+
from __future__ import absolute_import
import re
-import six
-
import os
strAide=self.parent.node.item.object.getFr()
if hasattr(self.parent.node.item.object.definition, 'defaut') :
strAide+='\ndefaut : \n'+str(self.parent.node.item.object.definition.defaut)
- strRapport=six.text_type(self.parent.node.item.object.report())
+ strRapport=str(self.parent.node.item.object.report())
self.parent.editor._viewText(strAide+"\n"+strRapport, "JDC_RAPPORT")
def mousePressEvent(self, event):
QToolTip.showText(event.globalPos(),myToolTip )
else :
t=""
- texte=six.text_type(self.parent.node.item.object.report())
+ texte=self.parent.node.item.object.report().report()
deb=1
for l in texte.split('\n')[2:-2]:
if re.match('^[\t !]*$',l) : continue
a l'utilisateur de choisir une seule valeur parmi une liste de valeurs
discretes
"""
- def __init__(self, parentAppli=None):
- QDialog.__init__(self,parent=parentAppli,flags=Qt.Window)
+ def __init__(self, appliEficas=None):
+ QDialog.__init__(self,parent=appliEficas,flags=Qt.Window)
self.setModal(True)
self.setupUi(self)
- self.parentAppli=parentAppli
+ self.appliEficas=appliEficas
self.verifieInstall()
self.code=None
self.buttonBox.accepted.disconnect(self.accept)
self.groupCodes.addButton(bouton)
except :
pass
- self.parentAppli.listeCode=self.parentAppli.listeCode+listeCodesIntegrateur
+ self.appliEficas.listeCode=self.appliEficas.listeCode+listeCodesIntegrateur
def choisitCode(self):
bouton=self.groupCodes.checkedButton()
if bouton==None : return
code=str(bouton.text())
codeUpper=code.upper()
- self.parentAppli.code=codeUpper
+ self.appliEficas.code=codeUpper
try :
dirCode=os.path.abspath(os.path.join(os.path.abspath(__file__),'../..',code))
l=os.listdir(dirCode)
a l'utilisateur de choisir une seule valeur parmi une liste de valeurs
discretes
"""
- def __init__(self, parentAppli=None):
- QDialog.__init__(self,parentAppli)
+ def __init__(self, appliEficas=None):
+ QDialog.__init__(self,appliEficas)
self.setModal(True)
self.setupUi(self)
- self.parentAppli=parentAppli
+ self.appliEficas=appliEficas
self.installLangue()
self.code=None
self.pB_OK.clicked.connect(self.choisitLangue)
def installLangue(self):
- if self.parentAppli.langue == 'fr' : self.rbFrancais.setChecked(True)
+ if self.appliEficas.langue == 'fr' : self.rbFrancais.setChecked(True)
else : self.rbEnglish.setChecked(True)
def choisitLangue(self):
- if self.rbFrancais.isChecked() : self.parentAppli.langue='fr'
- else : self.parentAppli.langue ='ang'
+ if self.rbFrancais.isChecked() : self.appliEficas.langue='fr'
+ else : self.appliEficas.langue ='ang'
self.close()
except : pass
import types,os
-from six.moves import range
from PyQt5.QtCore import Qt
import traceback
from Extensions.i18n import tr
-import six
from PyQt5.QtWidgets import QDialog, QMessageBox, QFileDialog
from PyQt5.QtCore import QSize
if fn == "" : return
if fn == None : return (0, None)
- ulfile = os.path.abspath(six.text_type(fn))
+ ulfile = os.path.abspath(fn)
if self.editor != None :
self.editor.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
try:
c.getPanel = self.getPanel
c.affichePanneau = self.affichePanneau
try :
- c.fenetre.RBDeplie.setCheckable(False)
+ c.fenetre.RBDeplie.setCheckable(False)
c.fenetre.RBDeplie.setEnabled(False)
c.fenetre.RBDeplie.setIcon(icon)
except :
except : pass
import types,os,re
-from six.moves import range
pattern_name = re.compile(r'^[^\d\W]\w*\Z')
# Modules Eficas
--- /dev/null
+# -*- coding: utf-8 -*-
+# Copyright (C) 2007-2020 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
+from __future__ import absolute_import
+import types,os
+
+
+# Modules Eficas
+from Extensions.i18n import tr
+from .monWidgetSimpTxt import MonWidgetSimpTxt
+from PyQt5.QtCore import Qt
+
+
+
+class MonWidgetCreeUserAssd ( MonWidgetSimpTxt):
+ def __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande):
+ MonWidgetSimpTxt. __init__(self,node,monSimpDef,nom,objSimp,parentQt,commande)
+ #self.lineEditVal.returnPressed.connect(self.LEValeurAjouteDsPossible)
+
+ def LEvaleurPressed(self):
+ try :
+ if str(self.lineEditVal.text())=="" or str(self.lineEditVal.text())==None : return
+ except : pass
+ valeurEntree = str(self.lineEditVal.text())
+ if valeurEntree == self.oldValeurTexte : return
+ if self.oldValeurTexte == "" : enCreation = True
+ else : enCreation = False
+ if enCreation : validite,commentaire=self.objSimp.creeUserASSDetSetValeur(valeurEntree)
+ else : validite,commentaire=self.objSimp.renommeSdCree(valeurEntree)
+ if not enCreation : self.node.updateNodeTexte()
+ #PNPNPN -- signal update sur les fils ou ?
+ if commentaire != "" :
+ if validite :
+ self.editor.afficheCommentaire(commentaire)
+ self.oldValeurTexte = self.lineEditVal.text()
+ else :
+ self.editor.afficheInfos(commentaire,Qt.red)
+ self.lineEditVal.setText("")
+
+
+
class MonWidgetFactCommun(Groupe):
"""
"""
- def __init__(self,node,editor,parentQt,definition, obj, niveau,commande,insertIn=-1):
+ def __init__(self,node,editor,parentQt,definition, obj, niveau,commande):
#print "fact : ",node.item.nom
Groupe.__init__(self,node,editor,parentQt, definition,obj,niveau,commande)
labeltext,fonte,couleur = self.node.item.getLabelText()
self.GroupBox.setText(tr(labeltext))
self.GroupBox.setTextInteractionFlags(Qt.TextSelectableByMouse)
- self.parentQt.commandesLayout.insertWidget(insertIn,self)
+ self.parentQt.commandesLayout.insertWidget(-1,self)
self.doitAfficherOptionnel=False
min,max=obj.getMinMax()
if max < 2 and hasattr(self, 'RBPlus') : self.RBPlus.close()
class MonWidgetFact(Ui_WidgetFact,MonWidgetFactCommun):
- def __init__(self,node,editor,parentQt,definition, obj, niveau,commande,insertIn=1):
- MonWidgetFactCommun.__init__(self,node,editor,parentQt, definition,obj,niveau,commande,insertIn)
+ #def __init__(self,node,editor,parentQt,definition, obj, niveau,commande,insertIn=1):
+ # MonWidgetFactCommun.__init__(self,node,editor,parentQt, definition,obj,niveau,commande,insertIn)
+ def __init__(self,node,editor,parentQt,definition, obj, niveau,commande):
+ MonWidgetFactCommun.__init__(self,node,editor,parentQt, definition,obj,niveau,commande)
-#class MonWidgetFactTableau(Ui_WidgetFactTableau,MonWidgetFactCommun):
class MonWidgetFactTableau(Ui_WidgetFact,MonWidgetFactCommun):
- def __init__(self,node,editor,parentQt,definition, obj, niveau,commande,insertIn=1):
- MonWidgetFactCommun.__init__(self,node,editor,parentQt, definition,obj,niveau,commande,insertIn)
- #print ('je passe dans FactTableau')
+ #def __init__(self,node,editor,parentQt,definition, obj, niveau,commande,insertIn=1):
+ # MonWidgetFactCommun.__init__(self,node,editor,parentQt, definition,obj,niveau,commande,insertIn)
+ def __init__(self,node,editor,parentQt,definition, obj, niveau,commande):
+ MonWidgetFactCommun.__init__(self,node,editor,parentQt, definition,obj,niveau,commande)
MonWidgetFactTableau.__init__(self,node,editor,parentQt, definition,obj,niveau,commande)
class MonWidgetFactPlie(Ui_WidgetFactPlie,Groupe):
"""
"""
- def __init__(self,node,editor,parentQt,definition, obj, niveau,commande,insertIn=-1):
+ #def __init__(self,node,editor,parentQt,definition, obj, niveau,commande,insertIn=-1):
+ def __init__(self,node,editor,parentQt,definition, obj, niveau,commande):
#print "fact plie : ",node.item.nom
node.fenetreAAfficher=self
Groupe.__init__(self,node,editor,parentQt, definition,obj,niveau,commande)
self.groupBox.setText(self.node.item.getLabelText()[0])
- self.parentQt.commandesLayout.insertWidget(insertIn,self)
+ self.parentQt.commandesLayout.insertWidget(-1,self)
def traiteClicSurLabel(self,texte):
return
import types,os
# Modules Eficas
-from six.moves import range
from PyQt5.QtWidgets import QCheckBox, QScrollBar, QFrame, QApplication, QLabel
from PyQt5.QtWidgets import QSizePolicy,QSpacerItem
from PyQt5.QtGui import QPalette, QFont
from desWidgetMatrice import Ui_desWidgetMatrice
-from six.moves import range
from PyQt5.QtCore import QSize, Qt
from PyQt5.QtWidgets import QTableWidgetItem
from PyQt5.QtGui import QIcon
from desWidgetParam import Ui_WidgetParam
from InterfaceQT4.gereIcones import FacultatifOuOptionnel
-import six
from PyQt5.QtWidgets import QWidget, QMessageBox
from PyQt5.QtGui import QIcon
try :
exec(monTexte, contexte)
except (ValueError,TypeError, NameError,RuntimeError,ZeroDivisionError) as exc:
- self.LECommentaire.setText(tr("Valeur incorrecte: ")+six.text_type (exc))
+ self.LECommentaire.setText(tr("Valeur incorrecte: ")+str(exc))
return False
except :
self.LECommentaire.setText(tr("Valeur incorrecte "))
from .monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
from .politiquesValidation import PolitiquePlusieurs
-from six.moves import range
from PyQt5.QtWidgets import QScrollBar
import types,os,sys
-from six.moves import range
from PyQt5.QtGui import QIcon
from PyQt5.QtWidgets import QApplication, QMessageBox, QScrollArea
from PyQt5.QtCore import QTimer, QSize, Qt
import types,os
# Modules Eficas
-from six.moves import range
from PyQt5.QtWidgets import QCheckBox, QScrollBar, QFrame, QApplication, QLabel
from PyQt5.QtWidgets import QSizePolicy,QSpacerItem
from PyQt5.QtGui import QPalette, QFont
from .gereListe import MonLabelListeClic
from Extensions.i18n import tr
-from six.moves import range
from PyQt5.QtWidgets import QFrame, QApplication, QScrollBar
from PyQt5.QtCore import QTimer, QSize, Qt
from PyQt5.QtGui import QIcon, QPalette
import types,os,sys
-from six.moves import range
from PyQt5.QtWidgets import QFrame,QApplication, QFrame, QWidget
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import QSize, Qt, QTimer
self.LEvaleurPressed()
QLineEdit.focusOutEvent(self.lineEditVal,event)
- #def showEvent(self, event):
- # if self.prendLeFocus==1 :
- # self.activateWindow()
- # self.lineEditVal.setFocus()
- # self.prendLeFocus=0
- # QWidget.showEvent(self,event)
def setValeurs(self):
#print ("dans setValeurs")
self.setValeurs()
self.reaffiche()
- #if self.objSimp.parent.nom == "MODEL" :
- # if self.objSimp.isValid():
- # self.objSimp.parent.change_fichier="1"
- #self.node.item.parent.buildInclude(None,"")
import types,os
-from six.moves import range
from PyQt5.QtCore import Qt
# Modules Eficas
def testeUneValeur(self,valeurentree):
commentaire = None
- #print ('testeUneValeur', valeurentree)
+ #import traceback
+ #traceback.print_stack()
valeur,validite=self.node.item.evalValeur(valeurentree)
if not validite :
commentaire = "impossible d'evaluer : %s " %repr(valeurentree)
except : pass
import os, sys
-import six
from PyQt5.QtWidgets import QApplication, QMainWindow, QGridLayout, QBoxLayout, QMenu, QAction, QMessageBox
try:
self.viewmanager.newEditor()
except EficasException as exc:
- msg = six.text_type(exc)
+ msg = str(exc)
if msg != "": QMessageBox.warning(self, tr(u"Erreur"), msg)
def openProcess(self):
try:
self.viewmanager.handleOpen()
except EficasException as exc:
- msg = six.text_type(exc)
+ msg = str(exc)
if msg != "":
QMessageBox.warning(self, tr(u"Erreur"), msg)
# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
#
+
from __future__ import absolute_import
from __future__ import print_function
try :
except : pass
import os, sys
-import six
from Extensions.eficas_exception import EficasException
from Extensions import param2
def initEditor(self,fichier = None,jdc = None, units = None,include=0):
if (hasattr(self, 'editor')) and self.editor != None :
print ('un seul editeur par application')
- sys.Exit()
- #self.editor = JDCEditorSsIhm(self,fichier, jdc, self.myQtab,units=units,include=include)
+ sys.exit()
self.editor = self.viewmanager.getNewEditorNormal()
def initEditorNormal(self,fichier = None,jdc = None, units = None,include=0):
return self.editor
def fileOpen(self,fichier):
- fichierIn = os.path.abspath(six.text_type(fichier))
+ fichierIn = os.path.abspath(fichier)
try:
monEditor=self.viewmanager.handleOpen(fichierIn)
except EficasException as exc:
if not hasattr(self, 'inSaisieValeur' ) : self.inSaisieValeur=False
if self.inSaisieValeur : return
self.inSaisieValeur=True
+
if valeur == None :
try :
nouvelleValeur=str(self.lineEditVal.text())
self.inSaisieValeur=False
return
else :
- #PN PN PN ???? la 1 ligne est tres bizarre.
try :
- if hasattr(self,"lineEditVal"):self.lineEditVal.setText(tr(valeur.nom))
+ # la 1 ligne est tres bizarre. remplacee par le 3nd le 01 10 19
+ #if hasattr(self,"lineEditVal"):self.lineEditVal.setText(tr(valeur.nom))
+ if hasattr(self,"lineEditVal") : self.lineEditVal.setText(tr(valeur))
except :
if hasattr(self,"lineEditVal"):self.lineEditVal.setText(valeur)
nouvelleValeur=valeur
+
if self.node.item.definition.validators != None :
- if self.node.item.definition.validators.verifItem(nouvelleValeur) !=1 :
+ if self.node.item.definition.validators.verifItem(nouvelleValeur) !=1 :
commentaire=self.node.item.definition.validators.infoErreurItem()
self.editor.afficheInfos(commentaire,Qt.red)
self.inSaisieValeur=False
return
+
nouvelleValeurFormat=self.politique.getValeurTexte(nouvelleValeur)
validite,commentaire=self.politique.recordValeur(nouvelleValeurFormat)
if commentaire != "" :
- #PNPNPNP Il faut trouver une solution pour les 2 cas
- # self.editor.afficheInfos(commentaire)
- #self.Commentaire.setText(tr(commentaire))
if validite :
self.editor.afficheCommentaire(commentaire)
else :
import os
from Extensions.i18n import tr
-import six
from PyQt5.QtWidgets import QFileDialog, QMessageBox
from PyQt5.QtCore import QFileInfo
self.mesIndexes = {}
self.appliEficas=appliEficas
self.editors = []
- self.dict_editors={}
+ self.dictEditors={}
self.untitledCount = 0
self.doubles = {}
self.myQtab = self.appliEficas.myQtab
-
self.myQtab.currentChanged.connect(self.indexChanged)
self.myQtab.tabCloseRequested.connect(self.closeTab)
def indexChanged(self):
index=self.myQtab.currentIndex()
- if index in self.dict_editors:
- editor=self.dict_editors[index]
+ if index in self.dictEditors:
+ editor=self.dictEditors[index]
+ if editor.jdc !=None :
+ CONTEXT.unsetCurrentJdC()
+ CONTEXT.setCurrentJdC(editor.jdc)
self.appliEficas.maConfiguration=editor.maConfiguration
self.appliEficas.code=editor.maConfiguration.code
self.appliEficas.setWindowTitle(editor.titre)
fichier = QFileDialog.getOpenFileName(self.appliEficas,
tr('Ouvrir Fichier'),
self.appliEficas.maConfiguration.savedir,
- extensions)
+ extensions)
fichier=fichier[0]
- fichier = os.path.abspath(six.text_type(fichier))
- ulfile = os.path.abspath(six.text_type(fichier))
+ fichier = os.path.abspath(fichier)
+ ulfile = os.path.abspath(fichier)
self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
self.appliEficas.addToRecentList(fichier)
- maPage=self.getEditor( fichier,units=units)
- if maPage: result = maPage
+ maPage = self.getEditor( fichier,units=units)
+ if maPage : result = maPage
if maPage : self.myQtab.setTabText(self.myQtab.indexOf(maPage),os.path.basename(fichier))
return result
def handleClose(self,doitSauverRecent = 1,texte=tr('&Quitter'),indexAFermer=None):
if doitSauverRecent : self.appliEficas.sauveRecents()
- if indexAFermer == None :index=self.myQtab.currentIndex()
+ if indexAFermer == None : index=self.myQtab.currentIndex()
else : index = indexAFermer
if index < 0 : return
- res=self.checkDirty(self.dict_editors[index],texte)
+ res=self.checkDirty(self.dictEditors[index],texte)
if res == 2 : return 2 # l utilisateur a annule
idx=index
- while idx < len(self.dict_editors) -1 :
- self.dict_editors[idx]=self.dict_editors[idx+1]
+ while idx < len(self.dictEditors) -1 :
+ self.dictEditors[idx]=self.dictEditors[idx+1]
idx = idx + 1
- del self.dict_editors[len (self.dict_editors) -1]
+ del self.dictEditors[len (self.dictEditors) -1]
try :
- del self.doubles[self.dict_editors[index]]
+ del self.doubles[self.dictEditors[index]]
except :
pass
self.myQtab.removeTab(index)
def run(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.run()
def saveRun(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.saveRun()
def handleCloseAll(self,texte=tr('Quitter')):
res=0
self.appliEficas.sauveRecents()
- while len(self.dict_editors) > 0 :
+ while len(self.dictEditors) > 0 :
self.myQtab.setCurrentIndex(0)
res=self.handleClose(0,texte)
if res==2 : return res # l utilsateur a annule
#print "passage dans handleRechercher"
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.handleRechercher()
def handleRechercherDsCatalogue(self):
#print "passage dans handleRechercher"
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.handleRechercherDsCatalogue()
def handleDeplier(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.handleDeplier()
def handleEditCopy(self):
#print "passage dans handleEditCopy"
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.handleEditCopy()
def handleEditCut(self):
#print "passage dans handleEditCut"
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.handleEditCut()
def handleEditPaste(self):
#print "passage dans handleEditPaste"
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.handleEditPaste()
def handleSupprimer(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.handleSupprimer()
def handleAjoutEtape(self,nomEtape):
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.handleAjoutEtape(nomEtape)
def handleViewJdcFichierSource(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- self.dict_editors[index].viewJdcSource()
+ self.dictEditors[index].viewJdcSource()
def ouvreArbre(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- self.dict_editors[index].ouvreArbre()
+ self.dictEditors[index].ouvreArbre()
def fermeArbre(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- self.dict_editors[index].fermeArbre()
+ self.dictEditors[index].fermeArbre()
def ajoutCommentaire(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.ajoutCommentaire()
def handleViewJdcRegles(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- self.dict_editors[index].viewJdcRegles()
+ self.dictEditors[index].viewJdcRegles()
def handleGestionParam(self):
index=self.myQtab.currentIndex()
if index < 0 :
QMessageBox.warning( self.appliEficas,tr(u"Creation Parametre indisponible"),tr(u"les parametres sont lies a un jeu de donnees"))
return
- self.dict_editors[index].gestionParam()
+ self.dictEditors[index].gestionParam()
def handleViewJdcRapport(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- self.dict_editors[index].viewJdcRapport()
+ self.dictEditors[index].viewJdcRapport()
def handleViewJdcPy(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- self.dict_editors[index].viewJdcPy()
+ self.dictEditors[index].viewJdcPy()
def saveCurrentEditor(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
if editor in self.doubles :
QMessageBox.warning(
None,
return
ok, newName = editor.saveFile()
if ok :
- fileName=os.path.basename(six.text_type(newName))
+ fileName=os.path.basename(newName)
self.myQtab.setTabText(index,fileName)
return ok
def saveCompleteCurrentEditor(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
ok, newName = editor.saveCompleteFile()
return ok
def sauveLigneCurrentEditor(self):
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
if editor in self.doubles :
QMessageBox.warning(
None,
return
ok, newName = editor.sauveLigneFile()
if ok :
- fileName=os.path.basename(six.text_type(newName))
+ fileName=os.path.basename(newName)
self.myQtab.setTabText(index,fileName)
return ok
-
def saveAsCurrentEditor(self):
index=self.myQtab.currentIndex()
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
oldName=editor.fichier
ok,newName = editor.saveFileAs()
if ok :
- fileName=os.path.basename(six.text_type(newName))
+ fileName=os.path.basename(newName)
self.myQtab.setTabText(index,fileName)
if editor in self.doubles :
if oldName != newName :
newWin = 0
double = None
indexEditor=0
- for indexEditor in self.dict_editors :
- editor=self.dict_editors[indexEditor]
+ for indexEditor in self.dictEditors :
+ editor=self.dictEditors[indexEditor]
if self.samePath(fichier, editor.getFileName()):
msgBox = QMessageBox()
msgBox.setWindowTitle(tr("Fichier"))
index=self.myQtab.currentIndex()
if index != -1 :
- self.dict_editors[index]=editor
+ self.dictEditors[index]=editor
return editor
def addView(self, win, fichier=None):
if res == 0:
(ok, newName) = editor.saveFile()
if ok:
- fileName=os.path.basename(six.text_type(newName))
+ fileName=os.path.basename(newName)
index=self.myQtab.currentIndex()
self.myQtab.setTabText(index,fileName)
return ok
def handleAjoutGroup(self,listeGroup):
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
editor.handleAjoutGroup(listeGroup)
def handleFonctionUtilisateur(self,laFonctionUtilisateur, lesArguments):
# Peut-etre a blinder un peu plus sur le nb d argument
index=self.myQtab.currentIndex()
if index < 0 : return
- editor=self.dict_editors[index]
+ editor=self.dictEditors[index]
if editor.getEtapeCourante() == None :
QMessageBox.information( self.appliEficas,
tr("Selectionner une etape"),
if hasattr(editor,p): listeParam.append(getattr(editor,p))
if p=="editor" : listeParam.append(editor)
if p=="etapeCourante" : listeParam.append(editor.getEtapeCourante())
- apply(laFonctionUtilisateur,listeParam)
+ laFonctionUtilisateur(*listeParam)
#--------------------------------
# Symetrique de ViewManager mais pas d heritage entre les 2
# dans le viewManager pas de souci pour savoir qui est le jdc sur lequel on travaille
-# ici en revanche.... c est moins sur
+# ici en revanche.... c est moins sur . voir avec le fichier
# --------------------------------
def __init__(self,appliEficas):
# ----------------------------------------------------------------------
def getNewEditor(self,fichier = None,jdc = None, units = None,include=0):
# ----------------------------------------------------------------------
+# il faudrait decider entre e handler ou non
+# le cas d usage n est pas tout a fait identique :
+# avec handler pour les utilisateurs avance
+# sans pour les utilisateurs encore plus ancvances et les tests
from InterfaceQT4.editorSsIhm import JDCEditorSsIhm
editor = JDCEditorSsIhm(self.appliEficas,fichier,jdc, units=units,include=include)
self.dictEditors[handler].saveFileLegerAs(fileName)
-# def handleClose(self,doitSauverRecent = 1,texte=tr('&Quitter')):
-# if doitSauverRecent : self.appliEficas.sauveRecents()
-# index=self.myQtab.currentIndex()
-# if index < 0 : return
-# res=self.checkDirty(self.dict_editors[index],texte)
-# if res == 2 : return 2 # l utilisateur a annule
-# index=self.myQtab.currentIndex()
-# idx=index
-# while idx < len(self.dict_editors) -1 :
-# self.dict_editors[idx]=self.dict_editors[idx+1]
-# idx = idx + 1
-# del self.dict_editors[len (self.dict_editors) -1]
-# try :
-# del self.doubles[self.dict_editors[index]]
-# except :
-# pass
-# self.myQtab.removeTab(index)
-# return res
-#
-
-#
-# def handleCloseAll(self,texte=tr('Quitter')):
-# res=0
-# self.appliEficas.sauveRecents()
-# while len(self.dict_editors) > 0 :
-# self.myQtab.setCurrentIndex(0)
-# res=self.handleClose(0,texte)
-# if res==2 : return res # l utilsateur a annule
-# return res
-#
-#
-#
-# def newEditor(self,include=0):
-# if self.appliEficas.demande==True :
-# self.appliEficas.definitCode(None,None)
-# if self.appliEficas.code == None:return
-# maPage=self.getEditor(include=include)
-#
-
-#
-# def handleViewJdcRegles(self):
-# index=self.myQtab.currentIndex()
-# if index < 0 : return
-# self.dict_editors[index].viewJdcRegles()
-#
-# def handleGestionParam(self):
-# index=self.myQtab.currentIndex()
-# if index < 0 :
-# QMessageBox.warning( self.appliEficas,tr(u"Creation Parametre indisponible"),tr(u"les parametres sont lies a un jeu de donnees"))
-# return
-# self.dict_editors[index].gestionParam()
-#
-#
-#
-# def saveCurrentEditor(self):
-# index=self.myQtab.currentIndex()
-# if index < 0 : return
-# editor=self.dict_editors[index]
-# if editor in self.doubles :
-# QMessageBox.warning(
-# None,
-# tr("Fichier Duplique"),
-# tr("Le fichier ne sera pas sauvegarde."),)
-# return
-# ok, newName = editor.saveFile()
-# if ok :
-# fileName=os.path.basename(six.text_type(newName))
-# self.myQtab.setTabText(index,fileName)
-# return ok
-#
-# def saveLegerCurrentEditor(self):
-# index=self.myQtab.currentIndex()
-# if index < 0 : return
-# editor=self.dict_editors[index]
-# ok, newName = editor.saveFileLeger()
-# return ok
-#
-# def sauveLigneCurrentEditor(self):
-# index=self.myQtab.currentIndex()
-# if index < 0 : return
-# editor=self.dict_editors[index]
-# if editor in self.doubles :
-# QMessageBox.warning(
-# None,
-# tr("Fichier Duplique"),
-# tr("Le fichier ne sera pas sauvegarde."),)
-# return
-# ok, newName = editor.sauveLigneFile()
-# if ok :
-# fileName=os.path.basename(six.text_type(newName))
-# self.myQtab.setTabText(index,fileName)
-# return ok
-#
-#
-# def saveAsCurrentEditor(self):
-# index=self.myQtab.currentIndex()
-# editor=self.dict_editors[index]
-# oldName=editor.fichier
-# ok,newName = editor.saveFileAs()
-# if ok :
-# fileName=os.path.basename(six.text_type(newName))
-# self.myQtab.setTabText(index,fileName)
-# if editor in self.doubles :
-# if oldName != newName :
-# del self.doubles[editor]
-# return ok
-#
-# def displayJDC(self,jdc,fn=None):
-# """
-# Public slot to display a file in an editor.
-# @param fn name of file to be opened
-# # insert filename into list of recently opened files
-# """
-# titre=None
-# if fn != None : titre=fn.split("/")[-1]
-# editor = self.getEditor(fichier= fn, jdc = jdc ,include=1)
-#
-
-##PNPNPNPN --> a affiner
-# if fichier is None:
-# self.untitledCount += 1
-# self.myQtab.addTab(win, tr("Fichier non encore nomme ", self.untitledCount))
-# #self.myQtab.addTab(win, str(self.appliEficas.code))
-# else:
-# liste=fichier.split('/')
-# txt = liste[-1]
-# if not QFileInfo(fichier).isWritable():
-# txt = '%s (ro)' % txt
-# self.myQtab.addTab(win,txt )
-# self.myQtab.setCurrentWidget(win)
-# self.currentEditor=win
-# win.setFocus()
-#
-# def getOpenStartDir(self) :
-# #PN --> Les Preferences
-# try :
-# userDir=os.path.expanduser("~/Eficas_install/")
-# return userDir
-# except :
-# return ""
-#
-#
-# def checkDirty(self, editor,texte):
-# """
-# Private method to check dirty status and open a message window.
-#
-# @param editor editor window to check
-# @return flag indicating successful reset of the dirty flag (boolean)
-# """
-# res=1
-# if (editor.modified) and (editor in self.doubles) :
-# msgBox = QMessageBox(None)
-# msgBox.setWindowTitle(tr("Fichier Duplique"))
-# msgBox.setText(tr("Le fichier ne sera pas sauvegarde."))
-# msgBox.addButton(texte,0)
-# msgBox.addButton(tr("&Annuler"),1)
-# res=msgBox.exec_()
-# if res == 0 : return 1
-# return 2
-# if editor.modified:
-# fn = editor.getFileName()
-# if fn is None: fn = tr('Noname')
-# msgBox = QMessageBox(None)
-# msgBox.setWindowTitle(tr("Fichier Modifie"))
-# msgBox.setText(tr("Le fichier ne sera pas sauvegarde."))
-# msgBox.addButton(tr("&Sauvegarder"),1)
-# msgBox.addButton(tr("&Quitter sans sauvegarder"),0)
-# msgBox.addButton(tr("&Annuler"),2)
-# res=msgBox.exec_()
-# if res == 2 : return res
-# if res == 0:
-# (ok, newName) = editor.saveFile()
-# if ok:
-# fileName=os.path.basename(six.text_type(newName))
-# index=self.myQtab.currentIndex()
-# self.myQtab.setTabText(index,fileName)
-# return ok
-# return res
-#
-# def handleAjoutGroup(self,listeGroup):
-# index=self.myQtab.currentIndex()
-# if index < 0 : return
-# editor=self.dict_editors[index]
-# editor.handleAjoutGroup(listeGroup)
"""
Classe de base pour definir des types de structures de donnees ASTER
equivalent d un concept ASTER
+ Doit_on garder tout ce qui concerne jeveux ?
"""
idracine = "SD"
#
if self.parent:
try:
- self.parent.NommerSdprod(self, nom)
+ self.parent.nommerSDProd(self, nom)
except AsException as e:
appel = N_utils.calleeWhere(niveau=2)
raise AsException(
"""Conversion de type.
"""
- def __init__(self, name, typ):
+ def __init__(self, name, typeACreer):
self.name = name
- self.typ = typ
+ self.typeACreer = typeACreer
def convert(self, obj):
"""Filtre liste
class TypeConversion(Conversion):
- """Conversion de type
+ """Conversion de typeACreer
"""
- def __init__(self, typ):
- Conversion.__init__(self, 'type', typ)
+ def __init__(self, typeACreer):
+ Conversion.__init__(self, 'type', typeACreer)
class IntConversion(TypeConversion):
return o
+class UserASSDConversion(TypeConversion):
+ def __init__(self, classUser):
+ TypeConversion.__init__(self, classUser)
+
+ def function(self, o):
+ import traceback
+ print ('je convertis : ', o, 'en ', self.typeACreer )
+ traceback.print_stack()
+ print ('__________________________________________________________ UserASSDConversion')
+ if o == None : return None
+ nouvelObj=self.typeACreer(o)
+ return nouvelObj
+
_convertI = IntConversion()
_convertR = FloatConversion()
def ConversionFactory(name, typ):
if name == 'type':
- if 'I' in typ:
- return _convertI
- elif 'R' in typ:
- return _convertR
+ if 'I' in typ : return _convertI
+ elif 'R' in typ : return _convertR
+ if name == 'UserASSD':
+ #print(typ)
+ return (UserASSDConversion(typ))
return None
self.validators = self.factories['validator'](validators)
else:
self.validators = validators
- self.doitSenregistrerComme = None
+ #self.doitSenregistrerComme = None
self.txtNomComplet=''
self.redefinit=False
new_sd = self.sd.__class__(etape=new_etape)
new_etape.sd = new_sd
if self.reuse == None:
- new_etape.parent.NommerSdprod(new_sd, self.sd.nom)
+ new_etape.parent.nommerSDProd(new_sd, self.sd.nom)
else:
new_sd.setName(self.sd.nom)
new_etape.copyIntern(self)
Reinitialise le nommage du concept de l'etape lors d'un changement de jdc
"""
if self.sd and self.reuse == None:
- self.parent.NommerSdprod(self.sd, self.sd.nom)
+ self.parent.nommerSDProd(self.sd, self.sd.nom)
def isInclude(self):
"""Permet savoir si on a affaire a la commande INCLUDE
"""
from __future__ import absolute_import
from .N_ASSD import ASSD
-import six
+try:basestring
+except NameError: basestring = str
+
class GEOM(ASSD):
return self.nom
def __convert__(cls, valeur):
- if isinstance(valeur, (str, six.text_type)) and len(valeur.strip()) <= 8:
+ if isinstance(valeur, basestring) and len(valeur.strip()) <= 8:
return valeur.strip()
raise ValueError(
_(u'On attend une chaine de caractères (de longueur <= 8).'))
cata_ord_dico=None, parent=None,
nom='SansNom', appliEficas=None, context_ini=None, **args):
self.procedure = procedure
+ print (self.procedure)
self.definition = definition
self.cata = cata
# PN pourquoi ?
# on met le jdc lui-meme dans le context global pour l'avoir sous
# l'etiquette "jdc" dans le fichier de commandes
self.g_context = {'jdc': self}
+ CONTEXT.unsetCurrentJdC()
+ CONTEXT.setCurrentJdC(self)
# Dictionnaire pour stocker tous les concepts du JDC (acces rapide par
# le nom)
- self.sds_dict = {}
- self.utilise_un_sds_dict = {}
+ self.sdsDict = {}
self.etapes = []
self.index_etapes = {}
self.mc_globaux = {}
- self.current_context = {}
+ self.currentContext = {}
self.condition_context = {}
self.index_etape_courante = 0
self.UserError = "UserError"
Cette methode execute le jeu de commandes compile dans le contexte
self.g_context de l'objet JDC
"""
+
CONTEXT.setCurrentStep(self)
# Le module nommage utilise le module linecache pour acceder
# au source des commandes du jeu de commandes.
import linecache
linecache.cache[self.nom] = 0, 0, self.procedure.split('\n'), self.nom
try:
+ #if 1 :
exec(self.exec_init, self.g_context)
for obj_cata in (self.cata,):
if type(obj_cata) == types.ModuleType:
# Update du dictionnaire des concepts
for sdnom, sd in list(self.context_ini.items()):
if isinstance(sd, ASSD):
- self.sds_dict[sdnom] = sd
+ self.sdsDict[sdnom] = sd
#if self.appliEficas != None:
# self.appliEficas.afficheInfos(
if self.appliEficas != None:
self.appliEficas.afficheInfos('')
+ #try :
+ # print ('PNPN')
except InterruptParsingError:
# interrupt the command file parsing used by FIN to ignore the end
# of the file
Cette methode ajoute etape dans la liste des etapes : self.etapes
et retourne un numero d'enregistrement
"""
- import traceback
- traceback.print_stack()
self.etapes.append(etape)
self.index_etapes[etape] = len(self.etapes) - 1
return self.gRegister(etape)
if sd != None and (etape.definition.reentrant == 'n' or etape.reuse is None):
# ATTENTION : On ne nomme la SD que dans le cas de non reutilisation
# d un concept. Commande non reentrante ou reuse absent.
- self.NommerSdprod(sd, nomsd)
+ self.nommerSDProd(sd, nomsd)
return sd
- def NommerSdprod(self, sd, sdnom, restrict='non'):
+ def nommerSDProd(self, sd, sdnom, restrict='non'):
"""
Nomme la SD apres avoir verifie que le nommage est possible : nom
non utilise
Si le nom est deja utilise, leve une exception
Met le concept cree dans le concept global g_context
"""
- o = self.sds_dict.get(sdnom, None)
+ o = self.sdsDict.get(sdnom, None)
if isinstance(o, ASSD):
raise AsException("Nom de concept deja defini : %s" % sdnom)
if sdnom in self._reserved_kw:
"Nom de concept invalide. '%s' est un mot-cle reserve." % sdnom)
# Ajoute a la creation (appel de regSD).
- self.sds_dict[sdnom] = sd
+ self.sdsDict[sdnom] = sd
sd.setName(sdnom)
# En plus si restrict vaut 'non', on insere le concept dans le contexte
if restrict == 'non':
self.g_context[sdnom] = sd
+ def regUserSD(self,sd):
+ # utilisee pour creer les references
+ # se contente d appeler la methode equivalente sur le jdc
+ id=self.regSD(sd)
+ self.nommerSDProd(sd,sd.nom)
+ return id
+
+
def regSD(self, sd):
"""
Methode appelee dans l __init__ d un ASSD lors de sa creation
# courante pendant le processus de construction des etapes.
# Si on insère des commandes (par ex, dans EFICAS), il faut prealablement
# remettre ce pointeur a 0
- # self.current_context.items() if isinstance(v, ASSD)])
+ # self.currentContext.items() if isinstance(v, ASSD)])
if self.parLot_user == 'NON':
- d = self.current_context = self.g_context.copy()
+ d = self.currentContext = self.g_context.copy()
if etape is None:
return d
# retirer les sd produites par 'etape'
index_etape = len(self.etapes)
if index_etape >= self.index_etape_courante:
# On calcule le contexte en partant du contexte existant
- d = self.current_context
+ d = self.currentContext
if self.index_etape_courante == 0 and self.context_ini:
d.update(self.context_ini)
liste_etapes = self.etapes[self.index_etape_courante:index_etape]
else:
- d = self.current_context = {}
+ d = self.currentContext = {}
if self.context_ini:
d.update(self.context_ini)
liste_etapes = self.etapes
co.executed = 1
return co
- def del_concept(self, nomsd):
+ def delConcept(self, nomsd):
"""
- Methode pour supprimer la reference d'un concept dans le sds_dict.
+ Methode pour supprimer la reference d'un concept dans le sdsDict.
Ne detruire pas le concept (different de supprime).
"""
try:
- del self.sds_dict[nomsd.strip()]
+ del self.sdsDict[nomsd.strip()]
except:
pass
# L'etape courante pour laquelle le contexte a ete calcule est
# memorisee dans self.index_etape_courante
# self.current_context.items() if isinstance(v, ASSD)])
+ print ('hjhj')
d = self.current_context = self.g_context.copy()
if etape is None:
return d
# On est dans le cas de la creation d'un nouveau concept
sd = etape.getSdProd()
if sd != None:
- self.NommerSdprod(sd, nomsd)
+ self.nommerSDProd(sd, nomsd)
return sd
- def NommerSdprod(self, sd, sdnom, restrict='non'):
+ def nommerSDProd(self, sd, sdnom, restrict='non'):
"""
Cette methode est appelee par les etapes internes de la macro.
La macro appelle le JDC pour valider le nommage.
if restrict == 'non':
# On demande le nommage au parent mais sans ajout du concept dans le contexte du parent
# car on va l'ajouter dans le contexte de la macro
- self.parent.NommerSdprod(sd, sdnom, restrict='oui')
+ self.parent.nommerSDProd(sd, sdnom, restrict='oui')
# On ajoute dans le contexte de la macro les concepts nommes
# Ceci est indispensable pour les CO (macro) dans un INCLUDE
self.g_context[sdnom] = sd
else:
# La demande de nommage vient probablement d'une macro qui a mis
# le concept dans son contexte. On ne traite plus que le nommage (restrict="oui")
- self.parent.NommerSdprod(sd, sdnom, restrict='oui')
+ self.parent.nommerSDProd(sd, sdnom, restrict='oui')
def deleteConceptAfterEtape(self, etape, sd):
"""
if etp.reuse:
new_sd.setName(etp.sd.nom)
else:
- self.NommerSdprod(new_sd, etp.sd.nom)
+ self.nommerSDProd(new_sd, etp.sd.nom)
new_etp.copyIntern(etp)
self.etapes.append(new_etp)
self.index_etapes[new_etp] = len(self.etapes) - 1
Reinitialise l'etape avec un nouveau jdc parent new_jdc
"""
if self.sd and self.reuse == None:
- self.parent.NommerSdprod(self.sd, self.sd.nom)
+ self.parent.nommerSDProd(self.sd, self.sd.nom)
for concept in self.sdprods:
- self.parent.NommerSdprod(concept, concept.nom)
+ self.parent.nommerSDProd(concept, concept.nom)
def reparent(self, parent):
"""
return l
+
def intersection_vide(dict1, dict2):
"""Verification qu'il n'y a pas de clé commune entre 'dict1' et 'dict2'."""
sk1 = set(dict1)
self.nom = nom
self.val = val
self.parent = parent
- self.valeur = self.GETVAL(self.val)
+ self.valeur = self.getValeurEffective(self.val)
if parent:
self.jdc = self.parent.jdc
self.niveau = self.parent.niveau
self.etape = None
self.mcListe = self.buildMc()
- def GETVAL(self, val):
+ def getValeurEffective(self, val):
"""
Retourne la valeur effective du mot-clé en fonction
de la valeur donnée. Defaut si val == None
- valeur : valeur du mot-clé simple en tenant compte de la valeur par défaut
"""
- #print ("MCSIMP, ------------------------")
- #print (self, val, definition, nom, parent)
- #print ("MCSIMP, ------------------------")
+ print ("MCSIMP, ------------------------")
+ print (self, val, definition, nom, parent)
self.definition = definition
self.nom = nom
self.val = val
self.parent = parent
- self.convProto = ConversionFactory('type', typ=self.definition.type)
- self.valeur = self.GETVAL(self.val)
- self.objPyxbDeConstruction = objPyxbDeConstruction
- self.listeNomsObjsCrees = []
if parent:
self.jdc = self.parent.jdc
if self.jdc : self.cata = self.jdc.cata
# Le mot cle simple a été créé sans parent
# est-ce possible ?
print ('je suis dans le else sans parent du build')
+ print (poum)
self.jdc = None
self.cata = None
self.niveau = None
self.etape = None
- if self.definition.doitSenregistrerComme != None :
- if self.definition.doitSenregistrerComme in list(self.jdc.utilise_un_sds_dict.keys()):
- self.jdc.utilise_un_sds_dict[self.definition.doitSenregistrerComme].append(self)
- else :
- self.jdc.utilise_un_sds_dict[self.definition.doitSenregistrerComme] = [self,]
+ print (self,val)
+ if self.definition.creeDesObjets :
+ self.convProto = ConversionFactory('UserASSD', self.definition.creeDesObjetsDeType)
+ # isinstance(val, self.definition.creeDesObjetsDeType) ne fonctionne pas car il y a un avec cata devant et l autre non
+ else :
+ self.convProto = ConversionFactory('type', typ=self.definition.type)
+ self.valeur = self.getValeurEffective(self.val)
+ print (self,val)
+ self.objPyxbDeConstruction = objPyxbDeConstruction
+ self.listeNomsObjsCrees = []
- def GETVAL(self, val):
+ def getValeurEffective(self, val):
"""
Retourne la valeur effective du mot-clé en fonction
de la valeur donnée. Defaut si val == None
"""
if (val is None and hasattr(self.definition, 'defaut')):
val = self.definition.defaut
+ if val in self.jdc.sdsDict.keys():
+ return self.jdc.sdsDict[val]
+ # dans le cas de lecture de .comm, il est possible que l objet est deja ete cree
+ # peut-etre devrait on aussi verifier que val est de type string ?
+ if self.definition.creeDesObjets :
+ if val != None and (not(val.__class__.__name__ == self.definition.creeDesObjetsDeType.__name__)) : val=self.convProto.convert(val)
+ return val
if self.convProto:
- val = self.convProto.convert(val)
+ val = self.convProto.convert(val)
return val
+ def creeUserASSDetSetValeur(self, val):
+ self.state='changed'
+ nomVal=val
+ if nomVal in self.jdc.sdsDict.keys():
+ if isinstance(self.jdc.sdsDict[nomVal],self.definition.creeDesObjetsDeType): return (1, 'concept deja reference')
+ else : return (0, 'concept d un autre type existe deja')
+ if self.convProto:
+ objVal = self.convProto.convert(nomVal)
+ return (self.setValeur(objVal), 'reference cree')
+
def getValeur(self):
"""
Retourne la "valeur" d'un mot-clé simple.
-# coding=utf-8
+## coding=utf-8
# Copyright (C) 2007-2017 EDF R&D
#
# This library is free software; you can redistribute it and/or
else:
return self
- def GETVAL(self, val):
+ def getValeurEffective(self, val):
"""
Retourne la valeur effective du mot-clé en fonction
de la valeur donnée. Defaut si val == None
def longueurDsArbre(self):
return 1
- def creeObjetClasse(self, classeACreer):
- # lors de la lecture du .comm, 1ere phase, les objets n existent pas
- # mais il ne faut pas mettre la valeur des MC utilisant la classe a None
- # sinon, le siValide ne peut rien faire
- # c est pourquoi il faut gerer listeDesValeursSupprimees
- # et une liste des valeurs qui peut contenir un melange objet/nom selon
- # la creation des objets dans le .comm
-
- if not hasattr(self,'listeNomsObjsCrees') : self.listeNomsObjsCrees = []
- newlisteNomsObjsCrees = []
- listeSupprimees = []
- change=False
- if not isinstance(self.valeur,(list, tuple)) : valTraitee = (self.valeur,)
- else : valTraitee = self.valeur
-
- for v in valTraitee:
- if not (v in self.listeNomsObjsCrees):
- change=True
- newObj=classeACreer(v)
- if v in list(self.jdc.sds_dict.keys()):
- if not isinstance (self.jdc.sds_dict[v], classeACreer):
- if not type(self.valeur) in (list, tuple) :self.Valeur=None
- else : self.valeur.remove(v)
- self.valeur=None
- self.state = 'undetermined'
- self.isValid()
- return
- self.jdc.sds_dict[v] = newObj
- newObj.sdnom = v
- newlisteNomsObjsCrees.append(v)
-
- for oldv in self.listeNomsObjsCrees :
- if oldv not in valTraitee :
- change=True
- listeSupprimees.append(self.jdc.sds_dict[oldv])
- self.jdc.sds_dict.pop(oldv)
- self.listeNomsObjsCrees.remove(oldv)
-
- for v in newlisteNomsObjsCrees :
- self.listeNomsObjsCrees.append(v)
-
- if not change : return
-
- if classeACreer in list(self.jdc.utilise_un_sds_dict.keys()):
- for MC in self.jdc.utilise_un_sds_dict[classeACreer] :
- if MC.valeur == None : return
- if MC.definition.max == 1 :
- if isinstance(MC.valeur, str) and MC.valeur in list(self.jdc.sds_dict.keys()):
- MC.valeur=self.jdc.sds_dict[MC.valeur]
- else :
- newVal=[]
- for val in MC.valeur :
- if isinstance(val, str) and val in list(self.jdc.sds_dict.keys()):
- newVal.append(self.jdc.sds_dict[val])
- else:
- newVal.append(val)
- MC.valeur=newVal
-
- if MC.definition.max == 1 :
- if MC.valeur in listeSupprimees:
- MC.valeur=None
- else :
- for val in MC.valeur :
- if val in listeSupprimees:
- MC.valeur=remove(val)
-
- MC.state = 'undetermined'
- MC.isValid()
class ErrorObj(OBJECT):
#print (self)
N_ENTITE.ENTITE.__init__(self, validators)
# Initialisation des attributs
+ self.creeDesObjets = False
if type(typ) == tuple:
self.type = typ
else:
self.type = (typ,)
for t in (self.type) :
- if isinstance(t,str): continue
- if isinstance(t,Accas.A_TUPLE.Tuple): continue
- try :
- if issubclass(t, Accas.UserASSD) : self.doitSenregistrerComme= t
+ try :
+ if issubclass(t,Accas.UserASSD) : creeDesObjetsDeType = t
except : pass
+ if t == 'createObject' : self.creeDesObjets=True
self.fr = fr
self.statut = statut
self.into = into
if self.val_min == '**' : self.val_min = float('-inf')
self.fenetreIhm=fenetreIhm
self.attribut = attribut
- self.creeDesObjetsDeType = creeDesObjetsDeType
+ if self.creeDesObjets : self.creeDesObjetsDeType = creeDesObjetsDeType
+ else : self.creeDesObjetsDeType = None
self.nomXML = nomXML
self.sortie=sortie
--- /dev/null
+# coding=utf-8
+# Copyright (C) 2007-2017 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 object
+except : pass
+import traceback
+
+from .N_ASSD import ASSD
+
+class UserASSD(ASSD):
+ """
+ Classe de base pour definir des types de structures de donnees definie par
+ l utilisateur
+ equivalent d un concept ASSD pour un SIMP ou un FACT
+ Attention : le parent est le JDC et non le MC createur que l on ne connait pas
+ """
+
+ def __init__(self,nom='sansNom'):
+ print ('dans l init de UserASSD', nom, type(nom))
+ #import traceback
+ #traceback.print_stack()
+ self.nom = nom
+ self.jdc = CONTEXT.getCurrentJdC()
+ self.parent = self.jdc
+ self.id = self.parent.regUserSD(self)
+ self.utilisePar=set()
+
+
+ def initialiseNom(self,nom):
+ print ('je passe par la pour', nom)
+ self.nom = nom
+
+ def ajoutUtilisePar(self,mc):
+ self.utilisePar.add(mc)
+
+ def enleveUtilisePar(self,mc):
+ try : self.utilisePar.remove(mc)
+ except : pass
+
+ def renomme(self,nouveauNom):
+ self.parent.delConcept(self.nom)
+ self.parent.sdsDict[nouveauNom] = self
+ self.setName(nouveauNom)
+
+
from __future__ import absolute_import
_root = None
_cata = None
+_jdc = None
debug = 0
# Le "current step" est l'etape courante.
"""
global _cata
_cata = None
+
+
+def getCurrentJdC():
+ """
+ Fonction qui retourne l'objet JDC courant
+ """
+ return _jdc
+
+def setCurrentJdC(jdc):
+ """
+ Fonction qui permet de changer l'objet JDC courant
+ """
+ global _jdc
+ if _jdc:
+ raise Exception("Impossible d'affecter _jdc. Il devrait valoir None")
+ _jdc = jdc
+
+def unsetCurrentJdC():
+ """
+ Fonction qui permet de remettre a None le JDC courant
+ """
+ global _jdc
+ _jdc = None
pass
import re
import linecache
+import sys
from functools import partial
# Modules EFICAS
lineno = f.f_lineno # XXX Too bad if -O is used
# lineno = f_lineno(f) # Ne marche pas toujours
co = f.f_code
- filename = six.text_type(co.co_filename, getEncoding())
+ if sys.version_info >= (3,0) :
+ filename = co.co_filename
+ else :
+ filename = six.text_type(co.co_filename, getEncoding())
name = co.co_name
# pattern pour identifier le debut de la commande
pattern_oper = re.compile(regex1 % ope)
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>DVisu</class>
- <widget class="QWidget" name="DVisu">
+ <widget class="QDialog" name="DVisu">
<property name="geometry">
<rect>
<x>0</x>
<string>...</string>
</property>
<property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/PlusBleu.png</normaloff>../Editeur/icons/PlusBleu.png</iconset>
+ <iconset theme="add"/>
</property>
<property name="iconSize">
<size>
</layout>
<zorder></zorder>
<zorder></zorder>
- <zorder>verticalSpacer_2</zorder>
- <zorder>line_7</zorder>
<zorder></zorder>
</widget>
<customwidgets>
<rect>
<x>0</x>
<y>0</y>
- <width>1122</width>
- <height>163</height>
+ <width>1002</width>
+ <height>91</height>
</rect>
</property>
<property name="sizePolicy">
<property name="styleSheet">
<string notr="true"/>
</property>
- <layout class="QHBoxLayout" name="horizontalLayout_2">
+ <layout class="QHBoxLayout" name="horizontalLayout_5">
<property name="spacing">
<number>0</number>
</property>
<number>2</number>
</property>
<property name="rightMargin">
- <number>2</number>
+ <number>0</number>
</property>
<property name="bottomMargin">
- <number>0</number>
+ <number>2</number>
</property>
<item>
<layout class="QVBoxLayout" name="verticalLayout_3">
<x>0</x>
<y>0</y>
<width>300</width>
- <height>111</height>
+ <height>60</height>
</rect>
</property>
<property name="sizePolicy">
</item>
<item>
<layout class="QVBoxLayout" name="verticalLayout_2">
- <property name="spacing">
- <number>0</number>
- </property>
<item>
<widget class="QScrollArea" name="scrollArea">
<property name="sizePolicy">
- <sizepolicy hsizetype="Expanding" vsizetype="MinimumExpanding">
+ <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
<property name="minimumSize">
<size>
<width>400</width>
- <height>50</height>
+ <height>20</height>
</size>
</property>
<property name="styleSheet">
- <string notr="true">
-
-</string>
+ <string notr="true"/>
</property>
<property name="frameShape">
- <enum>QFrame::Box</enum>
+ <enum>QFrame::NoFrame</enum>
</property>
<property name="frameShadow">
<enum>QFrame::Plain</enum>
<rect>
<x>0</x>
<y>0</y>
- <width>705</width>
- <height>122</height>
+ <width>589</width>
+ <height>44</height>
</rect>
</property>
<property name="sizePolicy">
- <sizepolicy hsizetype="Expanding" vsizetype="MinimumExpanding">
+ <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
<horstretch>0</horstretch>
<verstretch>0</verstretch>
</sizepolicy>
</property>
<layout class="QVBoxLayout" name="verticalLayoutLE">
<property name="spacing">
- <number>2</number>
+ <number>0</number>
</property>
<property name="leftMargin">
<number>2</number>
<number>0</number>
</property>
<item>
- <spacer name="verticalSpacer_2">
+ <spacer name="verticalSpacer_3">
<property name="orientation">
<enum>Qt::Vertical</enum>
</property>
+ <property name="sizeType">
+ <enum>QSizePolicy::Fixed</enum>
+ </property>
<property name="sizeHint" stdset="0">
<size>
<width>20</width>
- <height>40</height>
+ <height>1</height>
</size>
</property>
</spacer>
</widget>
</item>
<item>
- <widget class="QFrame" name="frame">
- <property name="frameShape">
- <enum>QFrame::Box</enum>
+ <layout class="QHBoxLayout" name="horizontalLayout_2">
+ <property name="sizeConstraint">
+ <enum>QLayout::SetFixedSize</enum>
</property>
- <layout class="QHBoxLayout" name="horizontalLayout_6">
- <property name="leftMargin">
- <number>0</number>
- </property>
- <property name="topMargin">
- <number>0</number>
- </property>
- <property name="rightMargin">
- <number>0</number>
- </property>
- <property name="bottomMargin">
- <number>0</number>
- </property>
- <item>
- <spacer name="horizontalSpacer_5">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeType">
- <enum>QSizePolicy::Fixed</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>13</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
+ <item>
+ <widget class="QFrame" name="frame2">
+ <property name="sizePolicy">
+ <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
+ <horstretch>0</horstretch>
+ <verstretch>0</verstretch>
+ </sizepolicy>
+ </property>
+ <property name="frameShape">
+ <enum>QFrame::Box</enum>
+ </property>
<layout class="QHBoxLayout" name="horizontalLayout_4">
<property name="spacing">
<number>0</number>
<property name="sizeConstraint">
<enum>QLayout::SetFixedSize</enum>
</property>
+ <property name="leftMargin">
+ <number>0</number>
+ </property>
+ <property name="topMargin">
+ <number>0</number>
+ </property>
+ <property name="rightMargin">
+ <number>0</number>
+ </property>
+ <property name="bottomMargin">
+ <number>0</number>
+ </property>
<item>
- <widget class="QToolButton" name="RBHaut">
+ <widget class="QToolButton" name="RBBas">
<property name="minimumSize">
<size>
<width>21</width>
<enum>Qt::ClickFocus</enum>
</property>
<property name="toolTip">
- <string>Remonte la ligne</string>
+ <string>Descend la ligne</string>
</property>
<property name="styleSheet">
<string notr="true">border : 0px</string>
<string>...</string>
</property>
<property name="icon">
- <iconset theme="go-up">
+ <iconset theme="go-down">
<normaloff>.</normaloff>.</iconset>
</property>
<property name="iconSize">
</widget>
</item>
<item>
- <widget class="QToolButton" name="RBBas">
+ <widget class="QToolButton" name="RBHaut">
<property name="minimumSize">
<size>
<width>21</width>
<enum>Qt::ClickFocus</enum>
</property>
<property name="toolTip">
- <string>Descend la ligne</string>
+ <string>Remonte la ligne</string>
</property>
<property name="styleSheet">
<string notr="true">border : 0px</string>
<string>...</string>
</property>
<property name="icon">
- <iconset theme="go-down">
+ <iconset theme="go-up">
<normaloff>.</normaloff>.</iconset>
</property>
<property name="iconSize">
<string>...</string>
</property>
<property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/MoinsBleu.png</normaloff>../Editeur/icons/MoinsBleu.png</iconset>
+ <iconset theme="remove"/>
</property>
<property name="iconSize">
<size>
<string>...</string>
</property>
<property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/PlusBleu.png</normaloff>../Editeur/icons/PlusBleu.png</iconset>
+ <iconset theme="add"/>
</property>
<property name="iconSize">
<size>
</property>
</widget>
</item>
- </layout>
- </item>
- <item>
- <spacer name="horizontalSpacer_2">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeType">
- <enum>QSizePolicy::Minimum</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="QToolButton" name="RBVoisListe">
- <property name="minimumSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- <property name="maximumSize">
- <size>
- <width>21</width>
- <height>31</height>
- </size>
- </property>
- <property name="focusPolicy">
- <enum>Qt::ClickFocus</enum>
- </property>
- <property name="toolTip">
- <string>Montre l'ensemble des valeurs</string>
- </property>
- <property name="styleSheet">
- <string notr="true">border : 0px</string>
- </property>
- <property name="text">
- <string>...</string>
- </property>
- <property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/verre-loupe-icone-6087-64.png</normaloff>../Editeur/icons/verre-loupe-icone-6087-64.png</iconset>
- </property>
- <property name="iconSize">
- <size>
- <width>32</width>
- <height>32</height>
- </size>
- </property>
- </widget>
- </item>
- <item>
- <spacer name="horizontalSpacer_4">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeType">
- <enum>QSizePolicy::Minimum</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <layout class="QHBoxLayout" name="horizontalLayout_5">
- <property name="spacing">
- <number>0</number>
- </property>
- <property name="sizeConstraint">
- <enum>QLayout::SetFixedSize</enum>
- </property>
<item>
- <widget class="QToolButton" name="RBSalome">
+ <widget class="QToolButton" name="RBVoisListe">
<property name="minimumSize">
<size>
<width>21</width>
<enum>Qt::ClickFocus</enum>
</property>
<property name="toolTip">
- <string>Sélectionne depuis Salome</string>
+ <string>Montre l'ensemble des valeurs</string>
</property>
<property name="styleSheet">
<string notr="true">border : 0px</string>
<string>...</string>
</property>
<property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/flecheSalome.png</normaloff>../Editeur/icons/flecheSalome.png</iconset>
+ <iconset theme="find"/>
</property>
<property name="iconSize">
<size>
</property>
</widget>
</item>
+ <item>
+ <widget class="QToolButton" name="RBSalome">
+ <property name="minimumSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="maximumSize">
+ <size>
+ <width>21</width>
+ <height>31</height>
+ </size>
+ </property>
+ <property name="focusPolicy">
+ <enum>Qt::ClickFocus</enum>
+ </property>
+ <property name="toolTip">
+ <string>Sélectionne depuis Salome</string>
+ </property>
+ <property name="styleSheet">
+ <string notr="true">border : 0px</string>
+ </property>
+ <property name="text">
+ <string>...</string>
+ </property>
+ <property name="icon">
+ <iconset>
+ <normaloff>../Editeur/icons/flecheSalome.png</normaloff>../Editeur/icons/flecheSalome.png</iconset>
+ </property>
+ <property name="iconSize">
+ <size>
+ <width>32</width>
+ <height>32</height>
+ </size>
+ </property>
+ </widget>
+ </item>
</layout>
- </item>
- </layout>
- </widget>
+ </widget>
+ </item>
+ <item>
+ <spacer name="horizontalSpacer_2">
+ <property name="orientation">
+ <enum>Qt::Horizontal</enum>
+ </property>
+ <property name="sizeHint" stdset="0">
+ <size>
+ <width>40</width>
+ <height>20</height>
+ </size>
+ </property>
+ </spacer>
+ </item>
+ </layout>
</item>
</layout>
</item>
</customwidget>
</customwidgets>
<tabstops>
- <tabstop>scrollArea</tabstop>
- <tabstop>RBHaut</tabstop>
- <tabstop>RBBas</tabstop>
<tabstop>RBMoins</tabstop>
- <tabstop>RBVoisListe</tabstop>
- <tabstop>RBSalome</tabstop>
- <tabstop>RBSalomeVue</tabstop>
<tabstop>BSelectFichier</tabstop>
<tabstop>RBPoubelle</tabstop>
</tabstops>
<rect>
<x>0</x>
<y>0</y>
- <width>1013</width>
+ <width>1386</width>
<height>538</height>
</rect>
</property>
<x>0</x>
<y>0</y>
<width>18</width>
- <height>174</height>
+ <height>189</height>
</rect>
</property>
<property name="sizePolicy">
<rect>
<x>0</x>
<y>0</y>
- <width>300</width>
+ <width>425</width>
<height>519</height>
</rect>
</property>
<rect>
<x>0</x>
<y>0</y>
- <width>297</width>
+ <width>421</width>
<height>474</height>
</rect>
</property>
<string>...</string>
</property>
<property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/MoinsBleu.png</normaloff>../Editeur/icons/MoinsBleu.png</iconset>
+ <iconset theme="remove">
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="iconSize">
<size>
<string>...</string>
</property>
<property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/PlusBleu.png</normaloff>../Editeur/icons/PlusBleu.png</iconset>
+ <iconset theme="add">
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="iconSize">
<size>
<string>...</string>
</property>
<property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/verre-loupe-icone-6087-64.png</normaloff>../Editeur/icons/verre-loupe-icone-6087-64.png</iconset>
+ <iconset theme="find">
+ <normaloff>.</normaloff>.</iconset>
</property>
<property name="iconSize">
<size>
<rect>
<x>0</x>
<y>0</y>
- <width>265</width>
+ <width>270</width>
<height>307</height>
</rect>
</property>
<string notr="true">border : 0px</string>
</property>
<property name="icon">
- <iconset>
+ <iconset theme="remove">
<normaloff>../Editeur/icons/MoinsBleu.png</normaloff>../Editeur/icons/MoinsBleu.png</iconset>
</property>
<property name="iconSize">
<string>...</string>
</property>
<property name="icon">
- <iconset>
+ <iconset theme="add">
<normaloff>../Editeur/icons/PlusBleu.png</normaloff>../Editeur/icons/PlusBleu.png</iconset>
</property>
<property name="iconSize">
<string>...</string>
</property>
<property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/verre-loupe-icone-6087-64.png</normaloff>../Editeur/icons/verre-loupe-icone-6087-64.png</iconset>
+ <iconset theme="find"/>
</property>
<property name="iconSize">
<size>
<string>...</string>
</property>
<property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/PlusBleu.png</normaloff>../Editeur/icons/PlusBleu.png</iconset>
+ <iconset theme="add"/>
</property>
<property name="iconSize">
<size>
<string notr="true">border : 0px</string>
</property>
<property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/MoinsBleu.png</normaloff>../Editeur/icons/MoinsBleu.png</iconset>
+ <iconset theme="remove"/>
</property>
<property name="iconSize">
<size>
<string>...</string>
</property>
<property name="icon">
- <iconset>
- <normaloff>../Editeur/icons/verre-loupe-icone-6087-64.png</normaloff>../Editeur/icons/verre-loupe-icone-6087-64.png</iconset>
+ <iconset theme="find"/>
</property>
<property name="iconSize">
<size>
"""
if CONTEXT.debug:
- print(("ETAPE.isValid ", self.nom))
+ print(("ETAPE.isValid ", self.nom, self.state))
+ import traceback
+ traceback.print_stack()
if self.state == 'unchanged':
return self.valid
else:
class MCSIMP(object):
"""
- COMMENTAIRE CCAR:
Cette classe est quasiment identique a la classe originale d'EFICAS
a part quelques changements cosmetiques et des chagements pour la
faire fonctionner de facon plus autonome par rapport a l'environnement
- propager l'eventuel changement d'etat au parent
"""
- if CONTEXT.debug:
- print(("ETAPE.isValid ", self.nom))
+ #print ("ETAPE.isValid ", self.nom, self.state)
+ #import traceback
+ #traceback.print_stack()
if self.state == 'unchanged':
return self.valid
else:
