--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import sys,os
+import raw.efficas as efficas
+import types
+
+sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..')))
+sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..','UiQT5')))
+
+
+from Accas import *
+
+
+# Attention pas d heritage possible (cf doc pyxbe)
+
+dictSIMPEficasXML= { 'typ' : 'typeAttendu', 'statut' : 'statut',
+ 'min_occurs': 'min' , 'max_occurs' : 'max',
+ 'homo' : 'homo' , 'position' : 'portee',
+ 'validators': 'validators' , 'sug' : 'valeur_sugg',
+ 'defaut' : 'ValeurDef' , 'into' : ('PlageValeur','into'),
+ 'val_min' : ('PlageValeur','borne_inf') , 'val_max' : ('PlageValeur','borne_sup'),
+ 'ang' : ('doc','ang') , 'fr' : ('doc','fr',) ,
+ 'docu' : ('doc','docu'),}
+
+dictSIMPXMLEficas = {'doc' : {'fr' : 'fr' , 'ang' : 'ang' , 'docu' : 'docu' },
+ 'PlageValeur' : {'borne_sup' : 'val_max' , 'into' : 'into' , 'borne_inf' : 'val_min' ,},
+ 'statut' : 'statut' , 'validators' : 'validators' , 'homo' : 'homo' ,
+ 'ValeurDef' : 'defaut' , 'min' : 'min_occurs' ,
+ 'valeur_sugg' : 'sug' , 'portee' : 'position' , 'max' : 'max_occurs' , }
+
+
+# ------------------------------
+class monSIMP (efficas.T_SIMP):
+# ------------------------------
+
+ def explore(self):
+ #print "je passe dans explore pour SIMP ", self.nom
+ self.dictArgsEficas={}
+ self.dictArgsEficas['typ']=self.typeAttendu
+ for nomXMLArg in dir(self) :
+ if nomXMLArg in dictSIMPXMLEficas.keys() :
+ nomEficasArg=dictSIMPXMLEficas[nomXMLArg]
+ argu=getattr(self,nomXMLArg)
+ if argu==None : continue
+ if type(nomEficasArg) == types.DictionaryType:
+ for nomXML in nomEficasArg.keys():
+ arguDecoupe=getattr(argu,nomXML)
+ nomEficasDecoupe=nomEficasArg[nomXML]
+ self.dictArgsEficas[nomEficasDecoupe]=arguDecoupe
+ else :
+ self.dictArgsEficas[nomEficasArg] = argu
+
+ #if argNew != None : print argNew
+ self.objAccas=A_SIMP.SIMP(**self.dictArgsEficas)
+ self.objAccas.nom=self.nom
+
+ def getAccasEquivalent(self):
+ return self.nom, self.objAccas
+
+# ------------------------------
+class monPROC(efficas.T_PROC):
+# ------------------------------
+ def explore(self):
+ #print "je passe dans explore pour PROC ", self.nom
+ #print self.content()
+ #print "________________"
+ self.dictConstruction={}
+ self.dictConstruction['nom']=self.nom
+
+ for obj in self.content():
+ #print obj
+ if hasattr(obj,'explore') : obj.explore()
+ if hasattr(obj,'getAccasEquivalent') :
+ nom,objetAccas=obj.getAccasEquivalent()
+ self.dictConstruction[nom]=objetAccas
+ self.dictConstruction['op']=None
+ self.objAccas=A_PROC.PROC(**self.dictConstruction)
+
+
+# ------------------------------
+class monFACT(efficas.T_FACT):
+# ------------------------------
+ def explore(self):
+ #print "je passe dans explore pour FACT ", self.nom
+ #print self.content()
+ self.dictConstruction={}
+ for obj in self.content():
+ if hasattr(obj,'explore') : obj.explore()
+ if hasattr(obj,'creeAccasEquivalent') :
+ nom,objetAccas=obj.creeAccasEquivalent()
+ self.dictConstruction[nom]=objetAccas
+ self.objAccas=A_FACT.FACT(**self.dictConstruction)
+
+ def getAccasEquivalent(self):
+ return self.nom, self.objAccas
+
+
+# ------------------------------
+class monCata(efficas.T_cata):
+# ------------------------------
+ def exploreCata(self):
+ # On positionne le contexte ACCAS
+ self.JdC = JDC_CATA (code = 'MED', execmodul = None,)
+ objAExplorer=self.commandes[0]
+ for obj in objAExplorer.content():
+ if hasattr(obj,'explore') : obj.explore()
+
+
+
+efficas.T_SIMP._SetSupersedingClass(monSIMP)
+efficas.T_FACT._SetSupersedingClass(monFACT)
+efficas.T_PROC._SetSupersedingClass(monPROC)
+efficas.T_cata._SetSupersedingClass(monCata)
+
+if __name__ == "__main__":
+# print dir(efficas)
+# print dir(efficas.T_SIMP)
+
+
+ xml = open('Cata_MED_FAM_test.xml').read()
+ SchemaMed = efficas.CreateFromDocument(xml)
+ SchemaMed.exploreCata()
+
+ #print dir(efficas.T_SIMP)
+ #print dir(efficas.T_SIMP)
+
+ #for maCommande in monCata.commandes :
+ # for monProc in maCommande.PROC:
+ # for monFact in monProc.FACT:
+ # for simp in monFact.SIMP:
+ # simp.creeAccasEquivalent()
--- /dev/null
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import sys,os
+import raw.efficas as efficas
+import types
+
+sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..')))
+
+
+from Accas import *
+
+# traiter le cas des tuples
+
+# ds l init du SIMP il manque siValide et fenetreIhm
+
+from mapDesTypes import dictSIMPEficasXML, dictSIMPXMLEficas
+from mapDesTypes import dictFACTEficasXML, dictFACTXMLEficas
+from mapDesTypes import dictPROCEficasXML, dictPROCXMLEficas
+from mapDesTypes import listeParamDeTypeTypeAttendu, listeParamDeTypeStr, dicoPourCast
+from mapDesTypes import listeParamEnListeSiMax, listeParamTjsEnListe
+
+
+
+# ------------------------------
+class objetDefinitionAccas:
+# ------------------------------
+
+ def argumentXMLToEficas(self):
+ # ---------------------------
+ # Attention, pas de validation pour l instant
+ # il faut verifier la coherence entre les types contenus dans defaut, sug ... et le typeAttendu
+ # tout cela dans une fonction verifie pas faite -)
+
+ # Recuperation parametres
+ self.dictArgsEficas={}
+ for nomXMLArg in dir(self) :
+ if nomXMLArg in self.dictATraiter :
+ nomEficasArg=self.dictATraiter[nomXMLArg]
+ argu=getattr(self,nomXMLArg)
+ if argu==None : continue
+
+ if type(nomEficasArg) == types.DictionaryType:
+ for nomXML in list(nomEficasArg.keys()):
+ arguDecoupe=getattr(argu,nomXML)
+ nomEficasDecoupe=nomEficasArg[nomXML]
+ if arguDecoupe == None : continue
+ self.dictArgsEficas[nomEficasDecoupe]=arguDecoupe
+ else :
+ self.dictArgsEficas[nomEficasArg] = argu
+
+ # Cast dans le bon type des parametres si necessaire
+ if 'min' in list(self.dictArgsEficas.keys()):
+ self.dictArgsEficas['min']=int(self.dictArgsEficas['min'])
+
+ if 'max' in list(self.dictArgsEficas.keys()):
+ if self.dictArgsEficas['max']== -1 : self.dictArgsEficas['max']="**"
+ else : self.dictArgsEficas['max']=int(self.dictArgsEficas['max'])
+
+ for param in list(self.dictArgsEficas.keys()):
+ if param in listeParamDeTypeStr :
+ self.dictArgsEficas[param]=unicode(self.dictArgsEficas[param])
+
+ # En 2.7 a revoir en 3 ? necessaire
+ self.nomObj=str(self.nom)
+
+
+
+
+ def getAccasEquivalent(self):
+ # ---------------------------
+ return self.nomObj, self.objAccas
+#
+
+# ---------------------------------------------------------
+class objetComposeDefinitionAccas (objetDefinitionAccas):
+# ---------------------------------------------------------
+ def exploreArbre(self):
+ # --------------------------
+ liste=[]
+ for obj in self.content(): liste.append(obj)
+ #liste.reverse()
+ # PNPNPN essayer de comprendre reverse ou non
+
+ for obj in liste:
+ if hasattr(obj,'explore') : obj.explore ()
+ if hasattr(obj,'getAccasEquivalent') :
+ nom,objetAccas=obj.getAccasEquivalent()
+ self.dictArgsEficas[nom]=objetAccas
+
+# ----------------------------------------------------
+class monSIMP (efficas.T_SIMP, objetDefinitionAccas):
+# ----------------------------------------------------
+
+ def explore(self):
+ # --------------------
+ # 2 arguments pour ne pas avoir a differencier les appels explore
+ self.dictATraiter= dictSIMPXMLEficas
+ self.argumentXMLToEficas()
+
+ self.objAccas=A_SIMP.SIMP(**self.dictArgsEficas)
+ self.objAccas.nom=self.nomObj
+
+ def argumentXMLToEficas(self):
+ # ----------------------------
+ objetDefinitionAccas.argumentXMLToEficas(self)
+ self.convertitEnListes()
+ self.convertitLesTypes()
+
+ def estListe(self):
+ # ---------------
+ if hasattr(self,'max') and self.max > 1 : return True
+ else : return False
+
+ def attendTuple(self):
+ # -------------------
+ return False
+
+ def convertitEnListes(self):
+ # ------------------------
+ # Cas des Tuples non traites
+ for param in listeParamTjsEnListe :
+ if param in self.dictArgsEficas :
+ if not self.attendTuple() :
+ self.dictArgsEficas[param]=[self.dictArgsEficas[param],]
+
+ if self.estListe() :
+ for param in listeParamEnListeSiMax:
+ if param in self.dictArgsEficas :
+ if not self.attendTuple() :
+ self.dictArgsEficas[param]=[self.dictArgsEficas[param],]
+
+ def convertitLesTypes(self):
+ # ------------------------
+ # Cas des Tuples non traites
+
+ typeAttendu = self.dictArgsEficas['typ']
+ if typeAttendu in list(dicoPourCast.keys()):
+ for param in listeParamDeTypeTypeAttendu :
+ if param in list(self.dictArgsEficas.keys()):
+ castDsLeTypeAttendu=dicoPourCast[typeAttendu]
+ valeurACaster=self.dictArgsEficas[param].typesimple
+ if not isinstance(valeurACaster, (list, tuple)) :
+ val=castDsLeTypeAttendu(valeurACaster)
+ self.dictArgsEficas[param]=val
+ else :
+ liste=[]
+ for val in valeurACaster : liste.append(castDsLeTypeAttendu(val))
+ self.dictArgsEficas[param]=liste
+
+
+# -------------------------------------------------------
+class monFACT(efficas.T_FACT, objetComposeDefinitionAccas):
+# -------------------------------------------------------
+ def explore(self):
+ # --------------------
+ print "je passe dans explore pour FACT ", self.nom
+
+ self.dictATraiter= dictFACTXMLEficas
+ self.argumentXMLToEficas()
+ self.exploreArbre()
+ self.objAccas=A_FACT.FACT(**self.dictArgsEficas)
+
+
+# ---------------------------------------------------------
+class monPROC(efficas.T_PROC, objetComposeDefinitionAccas):
+# ---------------------------------------------------------
+ def explore(self,cata):
+ # --------------------
+ print "je passe dans explore pour PROC ", self.nom
+ self.dictATraiter= dictPROCXMLEficas
+ self.argumentXMLToEficas()
+ self.exploreArbre()
+ self.dictArgsEficas['op']=None
+
+ self.objAccas=A_PROC.PROC(**self.dictArgsEficas)
+ setattr(cata, self.nomObj,self.objAccas)
+ cata.contexteXML[self.nomObj]=self.objAccas
+
+# ------------------------------
+class monCata(efficas.T_cata):
+# ------------------------------
+ def exploreCata(self):
+ # On positionne le contexte ACCAS
+ self.JdC = JDC_CATA (code = 'MED', execmodul = None,)
+ self.contexteXML={}
+ objAExplorer=self.commandes[0]
+ for obj in objAExplorer.content():
+ if hasattr(obj,'explore') : obj.explore(self)
+ #print dir(self.JdC)
+
+
+ def dumpXSD(self):
+ for etape in self.contexteXML.values() :
+ etape.dumpXSD()
+
+efficas.T_SIMP._SetSupersedingClass(monSIMP)
+efficas.T_FACT._SetSupersedingClass(monFACT)
+efficas.T_PROC._SetSupersedingClass(monPROC)
+efficas.T_cata._SetSupersedingClass(monCata)
+
+if __name__ == "__main__":
+# print dir(efficas)
+# print dir(efficas.T_SIMP)
+
+ xml = open('cata_test1.xml').read()
+ SchemaMed = efficas.CreateFromDocument(xml)
+ SchemaMed.exploreCata()
+ #SchemaMed.dumpXSD()
+
--- /dev/null
+def inverseDico(dicoSource) :
+#---------------------------
+ dicoInverse = {}
+ for (clef,valeur) in dicoSource.items():
+ if not(type(valeur) is tuple):
+ dicoInverse[valeur]=clef
+ continue
+ (elt,att)=valeur
+ if elt not in dicoInverse : dicoInverse[elt]={}
+ dicoInverse[elt][att]=clef
+ return dicoInverse
+
+dictSIMPEficasXML= { 'typ' : 'typeAttendu',
+ 'statut' : 'statut',
+ 'min' : 'minOccurences',
+ 'max' : 'maxOccurences',
+ 'homo' : 'homo' ,
+ 'position' : 'portee',
+ 'validators' : 'validators' ,
+ 'sug' : 'valeurSugg',
+ 'defaut' : 'valeurDef' ,
+ 'into' : ('plageValeur','into'),
+ 'val_min' : ('plageValeur','borneInf'),
+ 'val_max' : ('plageValeur','borneSup'),
+ 'ang' : ('doc','ang'),
+ 'fr' : ('doc','fr',),
+ 'docu' : ('doc','docu'),
+ }
+
+dictSIMPXMLEficas= inverseDico(dictSIMPEficasXML)
+
+
+
+dictFACTEficasXML = { 'statut' : 'statut',
+ 'min' : 'minOccurences',
+ 'max' : 'maxOccurences',
+ 'ang' : ('doc','ang'),
+ 'fr' : ('doc','fr',),
+ 'docu' : ('doc','docu'),
+ 'validators' : 'validators' ,
+ }
+
+dictFACTXMLEficas = inverseDico(dictFACTEficasXML)
+
+dictPROCEficasXML = { 'nom' : 'nom',
+ 'regles' : 'regles',
+ 'ang' : ('doc','ang'),
+ 'fr' : ('doc','fr',),
+ 'docu' : ('doc','docu'),
+ }
+ # 'UIinfo' : 'UIinfo'
+ # 'reentrant'
+ # 'repetable'
+ # 'op_init'
+ # 'fenetreIhm' : 'fenetreIhm'
+
+dictPROCXMLEficas = inverseDico(dictPROCEficasXML)
+
+listeParamDeTypeTypeAttendu = ( 'defaut', 'sug', 'val_min', 'val_max', 'into')
+listeParamDeTypeStr = ('fr', 'docu', 'ang', 'nom' )
+dicoPourCast = { 'I' : int, 'R' : float }
+
+listeParamTjsEnListe = ('into')
+listeParamEnListeSiMax = ('defaut', 'into', 'sug')
+
+if __name__ == "__main__":
+ import pprint
+ pp=pprint.PrettyPrinter(indent=4)
+ print ('dictSIMPEficasXML')
+ pp.pprint(dictSIMPEficasXML)
+ print ('\n\n')
+ print ('dictSIMPXMLEficas')
+ pp.pprint(dictSIMPXMLEficas)
+ print ('\n\n')
+ print ('dictFACTEficasXML')
+ pp.pprint(dictFACTEficasXML)
+ print ('\n\n')
+ print ('dictFACTXMLEficas')
+ pp.pprint(dictFACTXMLEficas)
+ print ('\n\n')
+ print ('dictPROCEficasXML')
+ pp.pprint(dictPROCEficasXML)
+ print ('\n\n')
+ print ('dictPROCXMLEficas')
+ pp.pprint(dictPROCXMLEficas)
from mapDesTypes import listeParamDeTypeTypeAttendu, listeParamDeTypeStr, dicoPourCast
from mapDesTypes import listeParamEnListeSiMax, listeParamTjsEnListe
+
+
# ------------------------------
class objetDefinitionAccas:
# ------------------------------
if self.dictArgsEficas['max']== -1 : self.dictArgsEficas['max']="**"
else : self.dictArgsEficas['max']=int(self.dictArgsEficas['max'])
- #for param in list(self.dictArgsEficas.keys()):
- # if param in listeParamDeTypeStr :
- # self.dictArgsEficas[param]=unicode(self.dictArgsEficas[param])
+ for param in list(self.dictArgsEficas.keys()):
+ if param in listeParamDeTypeStr :
+ self.dictArgsEficas[param]=unicode(self.dictArgsEficas[param])
+
+ # En 2.7 a revoir en 3 ? necessaire
+ self.nomObj=str(self.nom)
+
- # Pour commodite ? pas sur que cela soit necessaire
- #self.strNomObj=str(self.nom)
def getAccasEquivalent(self):
# ---------------------------
- return self.nom, self.objAccas
+ return self.nomObj, self.objAccas
#
# ---------------------------------------------------------
# --------------------------
liste=[]
for obj in self.content(): liste.append(obj)
- liste.reverse()
+ #liste.reverse()
# PNPNPN essayer de comprendre reverse ou non
for obj in liste:
self.argumentXMLToEficas()
self.objAccas=A_SIMP.SIMP(**self.dictArgsEficas)
- self.objAccas.nom=self.nom
- #self.strNomObj=str(self.nom)
+ self.objAccas.nom=self.nomObj
def argumentXMLToEficas(self):
# ----------------------------
val=castDsLeTypeAttendu(valeurACaster)
self.dictArgsEficas[param]=val
else :
- print (dir(self.dictArgsEficas[param]))
- print ('==========', self.dictArgsEficas)
+ liste=[]
+ for val in valeurACaster : liste.append(castDsLeTypeAttendu(val))
+ self.dictArgsEficas[param]=liste
# -------------------------------------------------------
# -------------------------------------------------------
def explore(self):
# --------------------
- #print "je passe dans explore pour FACT ", self.nom
+ print "je passe dans explore pour FACT ", self.nom
self.dictATraiter= dictFACTXMLEficas
self.argumentXMLToEficas()
# ---------------------------------------------------------
def explore(self,cata):
# --------------------
- #print "je passe dans explore pour PROC ", self.nom
+ print "je passe dans explore pour PROC ", self.nom
self.dictATraiter= dictPROCXMLEficas
self.argumentXMLToEficas()
self.exploreArbre()
self.dictArgsEficas['op']=None
self.objAccas=A_PROC.PROC(**self.dictArgsEficas)
- setattr(cata, self.nom,self.objAccas)
-
+ setattr(cata, self.nomObj,self.objAccas)
+ cata.contexteXML[self.nomObj]=self.objAccas
# ------------------------------
class monCata(efficas.T_cata):
# ------------------------------
def exploreCata(self):
# On positionne le contexte ACCAS
- self.VERSION_CATALOGUE='V1'
self.JdC = JDC_CATA (code = 'MED', execmodul = None,)
- self.fromXML=1
+ self.contexteXML={}
objAExplorer=self.commandes[0]
for obj in objAExplorer.content():
if hasattr(obj,'explore') : obj.explore(self)
#print dir(self.JdC)
+ def dumpXSD(self):
+ for etape in self.contexteXML.values() :
+ etape.dumpXSD()
efficas.T_SIMP._SetSupersedingClass(monSIMP)
efficas.T_FACT._SetSupersedingClass(monFACT)
# print dir(efficas)
# print dir(efficas.T_SIMP)
-
- xml = open('cata_test1.xml').read()
- #xml = open('Cata_MED_FAM.xml').read()
+ #xml = open('cata_test1.xml').read()
+ xml = open('Cata_MED_FAM_test.xml').read()
SchemaMed = efficas.CreateFromDocument(xml)
SchemaMed.exploreCata()
- #print dir(SchemaMed)
- #print dir(SchemaMed.FAS)
- #print SchemaMed.FAS
-
- #print dir(efficas.T_SIMP)
- #print dir(efficas.T_SIMP)
-
- #for maCommande in monCata.commandes :
- # for monProc in maCommande.PROC:
- # for monFact in monProc.FACT:
- # for simp in monFact.SIMP:
- # simp.creeAccasEquivalent()
+ #SchemaMed.dumpXSD()
+
+++ /dev/null
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-import sys,os
-import raw.efficas as efficas
-import types
-import pyxb
-
-sys.path.insert(0,os.path.abspath(os.path.join(os.getcwd(),'..')))
-
-
-from Accas import *
-
-
-# Attention pas d heritage possible (cf doc pyxbe)
-# bizarre le comportement de max est different entre les facts et les simps ?
-
-dictSIMPEficasXML= { 'typ' : 'typeAttendu', 'statut' : 'statut',
- 'min_occurs': 'min' , 'max_occurs' : 'max',
- 'homo' : 'homo' , 'position' : 'portee',
- 'validators': 'validators' , 'sug' : 'valeur_sugg',
- 'defaut' : 'valeurDef' , 'into' : ('plageValeur','into'),
- 'val_min' : ('plageValeur','borne_inf') , 'val_max' : ('plageValeur','borne_sup'),
- 'ang' : ('doc','ang') , 'fr' : ('doc','fr',) ,
- 'docu' : ('doc','docu'),}
-
-dictSIMPXMLEficas = {'doc' : {'fr' : 'fr' , 'ang' : 'ang' , 'docu' : 'docu' },
- 'plageValeur' : {'borne_sup' : 'val_max' , 'into' : 'into' , 'borne_inf' : 'val_min' ,},
- 'statut' : 'statut' , 'validators' : 'validators' , 'homo' : 'homo' ,
- 'valeurDef' : 'defaut' , 'min_occurs' : 'min' ,
- 'valeur_sugg' : 'sug' , 'portee' : 'position' , 'max_occurs' : 'max' , }
-
-dictFACTXMLEficas = {'doc' : {'fr' : 'fr' , 'ang' : 'ang' , 'docu' : 'docu' },
- 'statut' : 'statut' , 'validators' : 'validators' ,
- 'min_occurs' : 'min' , 'max_occurs' : 'max' , }
-
-## ------------------------------
-#class monSIMP (efficas.T_SIMP):
-## ------------------------------
-#
-# def explore(self,cata):
-# #print "je passe dans explore pour SIMP ", self.nom
-# self.dictArgsEficas={}
-# self.dictArgsEficas['typ']=self.typeAttendu
-# for nomXMLArg in dir(self) :
-# if nomXMLArg in dictSIMPXMLEficas.keys() :
-# nomEficasArg=dictSIMPXMLEficas[nomXMLArg]
-# argu=getattr(self,nomXMLArg)
-# if argu==None : continue
-# if nomEficasArg == 'defaut' : print (argu);
-# if nomEficasArg == 'defaut' : print (dir(argu));
-# if nomEficasArg == 'defaut' : print (argu.value)
-# #if nomEficasArg == 'defaut' : print (efficas.T_I(argu))
-# if nomEficasArg == 'defaut' : print (argu.content())
-# if type(nomEficasArg) == types.DictionaryType:
-# for nomXML in nomEficasArg.keys():
-# arguDecoupe=getattr(argu,nomXML)
-# nomEficasDecoupe=nomEficasArg[nomXML]
-# self.dictArgsEficas[nomEficasDecoupe]=arguDecoupe
-# else :
-# self.dictArgsEficas[nomEficasArg] = argu
-#
-# if 'min' in self.dictArgsEficas.keys(): self.dictArgsEficas['min']=int(self.dictArgsEficas['min'])
-# if 'max' in self.dictArgsEficas.keys():
-# if self.dictArgsEficas['max']== -1 : self.dictArgsEficas['max']="**"
-# else : self.dictArgsEficas['max']=int(self.dictArgsEficas['max'])
-# self.objAccas=A_SIMP.SIMP(**self.dictArgsEficas)
-# self.objAccas.nom=self.nom
-# self.strNomObj=str(self.nom)
-#
-# def getAccasEquivalent(self):
-# return self.strNomObj, self.objAccas
-#
-## ------------------------------
-#class monPROC(efficas.T_PROC):
-## ------------------------------
-# def explore(self,cata):
-# #print "je passe dans explore pour PROC ", self.nom
-# self.dictConstruction={}
-# self.dictConstruction['nom']=self.nom
-# liste=[]
-# for obj in self.content(): liste.append(obj)
-# liste.reverse()
-# for obj in liste:
-# if hasattr(obj,'explore') : obj.explore (cata)
-# if hasattr(obj,'getAccasEquivalent') :
-# nom,objetAccas=obj.getAccasEquivalent()
-# self.dictConstruction[nom]=objetAccas
-# self.dictConstruction['op']=None
-# self.objAccas=A_PROC.PROC(**self.dictConstruction)
-# self.strNomObj=str(self.nom)
-# setattr(cata, self.strNomObj,self.objAccas)
-#
-#
-## ------------------------------
-#class monFACT(efficas.T_FACT):
-## ------------------------------
-# def explore(self,cata):
-# #print "je passe dans explore pour FACT ", self.nom
-# self.dictConstruction={}
-#
-# for nomXMLArg in dir(self) :
-# if nomXMLArg in dictFACTXMLEficas.keys() :
-# nomEficasArg=dictFACTXMLEficas[nomXMLArg]
-# argu=getattr(self,nomXMLArg)
-# if argu==None : continue
-# argu=str(argu)
-# if type(nomEficasArg) == types.DictionaryType:
-# for nomXML in nomEficasArg.keys():
-# arguDecoupe=getattr(argu,nomXML)
-# nomEficasDecoupe=nomEficasArg[nomXML]
-# self.dictConstruction[nomEficasDecoupe]=arguDecoupe
-# else :
-# self.dictConstruction[nomEficasArg] = argu
-# if 'min' in self.dictConstruction.keys(): self.dictConstruction['min']=int(self.dictConstruction['min'])
-# if 'max' in self.dictConstruction.keys():
-# if self.dictConstruction['max']== '-1' : self.dictConstruction['max']="**"
-# else : self.dictConstruction['max']=int(self.dictConstruction['max'])
-# liste=[]
-# for obj in self.content(): liste.append(obj)
-# liste.reverse()
-# for obj in liste:
-# if hasattr(obj,'explore') : obj.explore(cata)
-# if hasattr(obj,'getAccasEquivalent') :
-# nom,objetAccas=obj.getAccasEquivalent()
-# self.dictConstruction[nom]=objetAccas
-#
-# self.objAccas=A_FACT.FACT(**self.dictConstruction)
-# self.strNomObj=str(self.nom)
-#
-# def getAccasEquivalent(self):
-# return self.strNomObj, self.objAccas
-#
-#
-## ------------------------------
-#class monCata(efficas.T_cata):
-## ------------------------------
-# def exploreCata(self):
-# # On positionne le contexte ACCAS
-# self.VERSION_CATALOGUE='V1'
-# self.JdC = JDC_CATA (code = 'MED', execmodul = None,)
-# self.fromXML=1
-# objAExplorer=self.commandes[0]
-# for obj in objAExplorer.content():
-# if hasattr(obj,'explore') : obj.explore(self)
-# #print dir(self.JdC)
-#
-#
-#
-#efficas.T_SIMP._SetSupersedingClass(monSIMP)
-#efficas.T_FACT._SetSupersedingClass(monFACT)
-#efficas.T_PROC._SetSupersedingClass(monPROC)
-#efficas.T_cata._SetSupersedingClass(monCata)
-#
-if __name__ == "__main__":
-
- #xml = open('Cata_MED_FAM.xml').read()
- #Cata = efficas.T_cata()
- #Commande=T_commandes()
- #T_PROC()
- #T_SIMP()
- print (dir(efficas.T_SIMP))
- print (dir(efficas.T_PROC))
- print (dir(efficas.T_cata))
-
- #pyxb.RequireValidWhenGenerating(False)
- #print(SchemaMed.toxml("utf-8").decode('utf-8'))
-
- #SchemaMed.exploreCata()
#if self.editor.code == 'ASTER' and not(self.item.isActif()) :
# posera des pb si un code decide d appeler FIN un mot clef
# on resoudera a ce moment la
- # pour l instant pas de poussiere sous le tapis
+ # pour l pas de poussiere sous le tapis
#print ('_________________ds affichePanneau pour', self.item.nom)
if not(self.item.isActif()) :
from .monWidgetInactif import MonWidgetInactif
#-----------------------------------------------------------------#
- def saveFileLeger(self, path = None, saveas= 0,formatLigne="beautifie"):
+ def saveCompleteFile(self, path = None, saveas= 0,formatLigne="beautifie"):
#-----------------------------------------------------------------#
extension='.casR'
- fn = self.fichier
+ fn = self.fichierComplet
#saveas=True # Pour forcer le nom
- self.generator=generator.plugins[self.format]()
- if self.fichier is None or saveas:
+ self.generator=self.maConfiguration.mesGenerators.plugins[self.format]()
+ if self.fichierComplet is None or saveas:
if path is None: path=self.maConfiguration.savedir
bOK, fn=self.determineNomFichier(path,extension)
if bOK == 0 : return (0, None)
self.appliEficas.maConfiguration.savedir=os.path.split(ulfile)[0]
fn = six.text_type(QDir.toNativeSeparators(fn))
- self.fichier = os.path.splitext(fn)[0]+extension
+ self.fichierComplet = os.path.splitext(fn)[0]+extension
- if hasattr(self.generator, "writeLeger"):
- self.generator.writeLeger(self.fichier,self.jdc,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
+ if hasattr(self.generator, "writeComplet"):
+ self.generator.writeComplet(self.fichierComplet,self.jdc,config=self.appliEficas.maConfiguration,appli=self.appliEficas)
- if self.salome : self.appliEficas.addJdcInSalome( self.fichier)
+ if self.salome : self.appliEficas.addJdcInSalome( self.fichierComplet)
self.modified = 0
- nouveauTitre=self.titre+" "+str(os.path.basename(self.fichier))
+ nouveauTitre=self.titre+" "+str(os.path.basename(self.fichierComplet))
self.appliEficas.setWindowTitle(nouveauTitre)
- return (1, self.fichier)
+ return (1, self.fichierComplet)
#-----------------------------------------------------------------#
def saveFile(self, path = None, saveas= 0,formatLigne="beautifie"):
if debug : print ('dans le init de JDCEditorSsIhm')
self.appliEficas = appli
- self.appli = appli
+ self.appli = appli
self.fichier = fichier
self.jdc = jdc
self.first = True
self.jdc_item = None
- self.dicoNouveauxMC={}
- self.dicoNouveauxFact={}
- self.dict_reels={}
- self.liste_simp_reel=[]
-
+ self.dicoNouveauxMC = {}
+ self.dicoNouveauxFact = {}
+ self.dict_reels = {}
+ self.liste_simp_reel = []
if appli != None : self.salome = self.appliEficas.salome
- else : self.salome=0
+ else : self.salome = 0
# ces attributs sont mis a jour par definitCode appelee par newEditor
self.code = self.appliEficas.maConfiguration.code
try:
self.maConfiguration.generator_module
_module = __import__(self.maConfiguration.generator_module)
- info = _module.entryPoint()
+ info = _module.entryPoint()
generator.plugins.addEntryPoint(info)
except:
pass
except :
pass
+ self.maConfiguration.mesGenerators = generator
+ self.maConfiguration.mesconvertisseurs = convert
+
self.fileInfo = None
self.lastModified = 0
if pourRun : jdc_formate=self.generator.textePourRun
if self.code == 'TELEMAC' : jdc_formate=self.generator.texteDico
except ValueError as e:
- self.afficheInfos( "Erreur a la generation",str(e),'red')
+ self.informe( "Erreur a la generation",str(e),'red')
return
if not self.generator.cr.estvide():
- self.afficheInfos("Erreur a la generation","EFICAS ne sait pas convertir ce JDC",'red')
+ self.informe("Erreur a la generation","EFICAS ne sait pas convertir ce JDC",'red')
return ""
else:
return jdc_formate
else:
# Il n'existe pas c'est une erreur
- self.afficheInfos("Format inconnu", self.format + " non reconnu" )
+ self.informe("Format inconnu", self.format + " non reconnu" )
return ""
#------------------------------#
import six
from six.moves import range
from PyQt5.QtWidgets import QLineEdit, QLabel, QFileDialog
-from PyQt5.QtCore import QEvent, Qt
+from PyQt5.QtCore import QEvent, Qt, QTimer
from PyQt5.QtGui import QIcon, QPalette
from Extensions.i18n import tr
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(7);return
+ if valeur=="" :
+ courant.setFocus(True)
+ self.estVisible=courant
+ return
def descendLesLignes(self):
# il faut donc surcharger un certain nb de fonction ici pour eux
-
-
def __init__(self,node,editor,etape):
+ #print ("debut de ---------------------- init de MonWidgetCommandeDeplie1Niveau ",node.item.nom)
MonWidgetCommande.__init__(self,node,editor,etape)
self.node.plieToutEtReaffiche=self.plieToutEtReaffiche
def afficheMots(self):
+ # Attention
+ # Attention --> cette methode surcharge les methodes des Nodes Fils
+ # Attention
#print ("debut de ---------------------- ds afficheMots de MonWidgetCommandeDeplie1Niveau ",self.node.item.nom)
#traceback.print_stack()
repIcon=self.editor.appliEficas.repIcon
#print ("fin ------------------------ afficheMots de MonWidgetCommandeDeplie1Niveau ",self.node.item.nom)
+ def afficheSuivant(self,aAfficher):
+ fenetre=self.node.tree.itemCourant.fenetre
+ fenetre.afficheSuivant(aAfficher)
+
def setDepliePourNode(self):
noeudCourant=self.node.tree.itemCourant
noeudCourant.setDeplieChildren()
pass
+# -------------------------------------------- Methodes qui surchargent les noeuds fils
+
def setDepliePourMCList(self):
#print ('je surcharge setDeplie pour MCList')
pass
def affichePanneau(self):
#print ('je surcharge affichePanneau', self.node.tree.itemCourant.item.getLabelText())
- item=self.node.tree.itemCourant.item
- self.setDepliePourNode()
+ node=self.node.tree.itemCourant
+ while ( not (hasattr(node,'fenetreIhm')) or node.treeParent.fenetreIhm != 'deplie1Niveau') :
+ node=node.treeParent
+ self.node.tree.setCurrentItem(node)
+
+ item=node.item
+ if item.getLabelText()[0] == self.editor.fenetreCentraleAffichee.labelNomCommande.text():
+ return
+ node.setDeplieChildren()
+ node.afficheCeNiveau()
self.editor.fenetreCentraleAffichee.labelNomCommande.setText(item.getLabelText()[0])
self.editor.fenetreCentraleAffichee.labelDoc.setText(item.getFr())
- def afficheSuivant(self,aAfficher):
- fenetre=self.node.tree.itemCourant.fenetre
- fenetre.afficheSuivant(aAfficher)
+
def getPanel (self):
- #print ('surcharge ds getPanel')
+ print ('surcharge ds getPanel')
pass
# deux lignes pour que le ensureVisible fonctionne
self.estVisible=nouveauLE
if self.inInit==False :QTimer.singleShot(1, self.rendVisibleLigne)
- #if donneLeFocus==True : nouveauLE.setFocus()
def etablitOrdre(self):
i=0
if len(self.listeValeursCourantes) > aConstruire : aConstruire=len(self.listeValeursCourantes)
self.indexDernierLabel = aConstruire
for i in range(1,aConstruire+1): self.ajoutLEResultat(i)
- else : self.indexDernierLabel= len(self.listeValeursCourantes)
index=1
for val in self.listeValeursCourantes :
nomLE="LEResultat"+str(index)
courant.setText(str(val))
courant.setReadOnly(True)
index=index+1
+ while (index < self.indexDernierLabel) :
+ nomLE="LEResultat"+str(index)
+ courant=getattr(self,nomLE)
+ courant.setText("")
+ courant.setReadOnly(True)
+ index=index+1
#self.prepareListeResultat()
def moinsPushed(self):
setattr(self,nomLE,nouveauLE)
def ajoutLineEdit(self):
- #print ('ajoutLineEdit')
+ print ('ajoutLineEdit')
self.indexDernierLabel=self.indexDernierLabel+1
self.ajoutLEResultat (self.indexDernierLabel)
self.estVisibleRE.setFocus()
self.scrollArea.ensureWidgetVisible(self.estVisibleRE,0,0)
#
+ def rendVisibleLigne(self):
+ self.estVisibleRE=self.estVisible
+ #rendVisibleLigneRE()
self.rechercherDejaLa=True
self.actionRechercherDsCatalogue.triggered.connect(self.handleRechercherDsCatalogue)
- def ajoutSortieLegere(self):
- if hasattr(self,'actionSortieLegere') : return
- self.actionSortieLegere = QAction(self)
- self.actionSortieLegere.setText(tr("Sortie Legere"))
- self.menuFichier.insertAction(self.actionEnregistrer_sous,self.actionSortieLegere)
- self.actionSortieLegere.triggered.connect(self.handleSortieLegere)
+ def ajoutSortieComplete(self):
+ if hasattr(self,'actionSortieComplete') : return
+ self.actionSortieComplete = QAction(self)
+ self.actionSortieComplete.setText(tr("Sortie Complete"))
+ self.menuFichier.insertAction(self.actionEnregistrer_sous,self.actionSortieComplete)
+ self.actionSortieComplete.triggered.connect(self.handleSortieComplete)
def MT(self):
self.enleverActionsStructures()
self.enlevernewInclude()
self.connectRechercherDsCatalogue()
- self.ajoutSortieLegere()
+ self.ajoutSortieComplete()
def lookSuiteTelemac(self):
self.enleverActionsStructures()
monOption=OptionPdf(parent=self,modal = 0 ,configuration=self.maConfiguration)
monOption.show()
- def handleSortieLegere(self):
- return self.viewmanager.saveLegerCurrentEditor()
+ def handleSortieComplete(self):
+ return self.viewmanager.saveCompleteCurrentEditor()
def handleShowRecentMenu(self):
"""
def dumpToXml(self):
- #from Efi2Xsd import readerEfficas
+ from Efi2Xsd import readerEfficas
print ('in dumpToXml')
#newSchema= xml = open('Cata_MED_FAM.xml').read()
#SchemaMed = efficas.CreateFromDocument(xml)
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:
def handleOpen(self,fichier=None,patron=0,units=None):
result = None
if fichier is None:
- if self.appliEficas.demande==True :
+ if self.appliEficas.demande==True :
self.appliEficas.definitCode(None,None)
if self.appliEficas.code == None:return
-
+
if self.appliEficas.code in DictExtensions:
chaine="JDC (*"+DictExtensions[self.appliEficas.code]+");;"
extensions=tr(chaine+ "All Files (*)")
pass
self.myQtab.removeTab(index)
return res
-
+
def run(self):
index=self.myQtab.currentIndex()
res=self.handleClose(0,texte)
if res==2 : return res # l utilsateur a annule
return res
-
+
def handleRechercher(self):
#print "passage dans handleRechercher"
index=self.myQtab.currentIndex()
if index < 0 : return
editor=self.dict_editors[index]
editor.handleDeplier()
-
+
def handleEditCopy(self):
#print "passage dans handleEditCopy"
index=self.myQtab.currentIndex()
def newEditor(self,include=0):
- if self.appliEficas.demande==True :
+ if self.appliEficas.demande==True :
self.appliEficas.definitCode(None,None)
if self.appliEficas.code == None:return
maPage=self.getEditor(include=include)
def handleGestionParam(self):
index=self.myQtab.currentIndex()
- if index < 0 :
+ 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.myQtab.setTabText(index,fileName)
return ok
- def saveLegerCurrentEditor(self):
+ def saveCompleteCurrentEditor(self):
index=self.myQtab.currentIndex()
if index < 0 : return
editor=self.dict_editors[index]
- ok, newName = editor.saveFileLeger()
+ ok, newName = editor.saveCompleteFile()
return ok
def sauveLigneCurrentEditor(self):
else :
from .editor import JDCEditor
editor = JDCEditor(self.appliEficas,fichier, jdc, self.myQtab,units=units,include=include)
- if double != None :
+ if double != None :
self.doubles[editor]=double
if editor.jdc: # le fichier est bien un jdc
self.editors.append(editor)
#PNPNPNPN --> a affiner
if fichier is None:
self.untitledCount += 1
- self.myQtab.addTab(win, tr("Fichier non encore nomme "+ self.appliEficas.readercata.versionCode, self.untitledCount))
+ self.myQtab.addTab(win, tr("Fichier non encore nomme " + self.appliEficas.readercata.versionCode, self.untitledCount))
+ #self.myQtab.addTab(win, str(self.appliEficas.code))
else:
liste=fichier.split('/')
txt = liste[-1]
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
+ """
+ res=1
if (editor.modified) and (editor in self.doubles) :
msgBox = QMessageBox(None)
msgBox.setWindowTitle(tr("Fichier Duplique"))
if index < 0 : return
editor=self.dict_editors[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()
tr("Selectionner une etape"),
tr("Le texte sera inséré après l étape selectionnée"))
- listeParam = []
+ listeParam = []
for p in lesArguments:
print (p)
if hasattr(editor,p): listeParam.append(getattr(editor,p))
# on écrit ses fils
self.formateEtape(element[1:])
#elif type(element) == types.StringType:
- elif type(element) == bytes:
+ #elif type(element) == bytes:
+ # PNPNPN -> marre du python 2 et 3
+ # on remplace par else dans if
+ else :
# il s'agit d'un mot-clé simple ou de ')' ou ');' ou '),' ou ');\n'
"""
#----------------------------------------------------------------------------------------
- def gener(self,obj,format='brut',config=None,appli=None,statut="Entier"):
+ def gener(self,obj,format='brut',config=None,appli=None,statut="Leger"):
self.statut = statut
self.langue = appli.langue
# ecriture de Leger
#----------------------------------------------------------------------------------------
- def writeLeger(self,fn,jdc,config,appli) :
- jdc_formate=self.gener(jdc,config=config,appli=appli,statut="Leger")
+ def writeComplet(self,fn,jdc,config,appli) :
+ jdc_formate=self.gener(jdc,config=config,appli=appli,statut="Entier")
self.writeDefault(fn)
