-import types
-class Tuple:
- def __init__(self,ntuple):
- self.ntuple=ntuple
+#
+from __future__ import absolute_import
+from Noyau import N_TUPLE
- def __convert__(self,valeur):
- try:
- if isinstance(valeur, basestring) : return None
- except NameError:
- if isinstance(valeur, str): return None
- if len(valeur) != self.ntuple: return None
- return valeur
-
- def info(self):
- return "Tuple de %s elements" % self.ntuple
+class Tuple (N_TUPLE.N_Tuple): pass
+class Matrice(N_TUPLE.N_Matrice): pass
from .A_EVAL import EVAL
from .A_NUPLET import NUPL
from .A_TUPLE import Tuple
+from .A_TUPLE import Matrice
from .A_JDC import JDC
if hasattr(self.type[0], 'typElt') :
#print ('je suis une Matrice de ' ,dictNomsDesTypes[self.type[0].typElt])
self.suisUneMatrice = True
+ # on presume que le type de l elt est un ASSD
+ if self.type[0].typElt not in dictNomsDesTypes.keys(): return 'xs:string'
return dictNomsDesTypes[self.type[0].typElt]
else :
self.suisUneMatrice = False
if self.state == 'unchanged':
return self.valid
for type_permis in self.definition.type:
- if hasattr(type_permis, "__class__") and type_permis.__class__.__name__ == 'Matrice':
+ #if hasattr(type_permis, "__class__") and type_permis.__class__.__name__ == 'Matrice':
+ if hasattr(type_permis, "typElt") :
self.monType=type_permis
return self.valideMatrice(cr=cr)
validite=Validation.V_MCSIMP.MCSIMP.isValid(self,cr=cr)
def valideMatrice(self,cr):
ok=1
+ commentaire =''
if self.valeur == None :
self.setValid(0)
return 0
+
if self.monType.methodeCalculTaille != None :
MCSIMP.__dict__[self.monType.methodeCalculTaille](*(self,))
+
if len(self.valeur) == self.monType.nbLigs :
for i in range(len(self.valeur)):
if len(self.valeur[i]) != self.monType.nbCols: ok=0
+ else : ok=0
+
if not ok :
self.setValid(0)
if cr == 'oui' :
self.cr.fatal(tr("La matrice n'est pas une matrice %(n_lign)d sur %(n_col)d", \
{'n_lign': self.monType.nbLigs, 'n_col': self.monType.nbCols}))
return 0
+
for i in range(self.monType.nbLigs):
for j in range(self.monType.nbCols):
val=self.valeur[i][j]
- if self.monType.typElt == 'R' :
- try : val=float(str(val))
- except : ok=0
- if self.monType.typElt == 'TXM' :
- if self.monType.typEltInto != None and val not in self.monType.typEltInto : ok=0
- if not ok :
- self.setValid(0)
- if cr == 'oui' :
- self.cr.fatal(tr("Les elements de la matrice ne sont pas d un bon type"))
- return 0
+ ok, commentaire = self.monType.verifItem(str(val),self.parent)
+ if self.monType.typElt not in ('TXM','I','R') and type(val) != self.monType.typElt :
+ ok=0; commentaire = 'mauvais type'; self.valeur=None
+ if not ok :
+ self.setValid(0)
+ if cr == 'oui' :
+ self.cr.fatal(tr(commentaire))
+ return 0
self.setValid(1)
return 1
"""
"""
def __init__(self,node,editor,parentQt,definition, obj, niveau,commande):
- print ("fact : ",node.item.nom)
+ #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))
# Modules Eficas
from Extensions.i18n import tr
from .feuille import Feuille
+from Extensions.eficas_exception import EficasException
from desWidgetMatrice import Ui_desWidgetMatrice
def monFocusOutEvent(self,event):
self.acceptVal()
- QTableWidget.focusInEvent(self.TBMatrice,event)
+ QTableWidget.focusOutEvent(self.TBMatrice,event)
def itemChanged(self):
if monItem==None : return
texte=monItem.text()
if texte=="" : return
- if self.monType.typElt == 'R' :
- try : val=float(str(texte)); ok=True
- except : ok=False
- if ok == False :
- self.editor.afficheInfos(tr("Entrer un float SVP"),Qt.red)
- monItem.setText("")
- return
- if self.monType.valSup != None :
- if val > self.monType.valSup :
- self.editor.afficheInfos(tr("Entrer un float inferieur a ") + repr(self.monType.valSup),Qt.red)
- monItem.setText("")
- return
- if self.monType.valMin != None :
- if val < self.monType.valMin :
- self.editor.afficheInfos(tr("Entrer un float superieur a ") + repr(self.monType.valMin),Qt.red)
- monItem.setText("")
- return
- self.editor.afficheInfos("")
- if self.monType.structure != None: MonWidgetMatrice.__dict__[self.monType.structure](*(self,))
- if self.monType.typElt == 'TXM' :
- if self.monType.typEltInto != None and texte not in self.monType.typEltInto :
- self.editor.afficheInfos(tr("Entrer une valeur qui est ") + str(self.monType.typEltInto),Qt.red)
- monItem.setText("")
- return
+ boolOk, commentaire = self.monType.verifItem(texte,self.node.item.object)
+ if not boolOk :
+ self.editor.afficheInfos(tr(commentaire),Qt.red)
+ monItem.setText("")
+ return
def creeColonnes(self):
monItem=self.TBMatrice.item(i,j)
if monItem : texte=monItem.text()
else : texte = ''
- if self.monType.typElt == 'R' :
- try : val=float(str(texte))
- except : val=None
- val=texte
+ if texte != '' : val=self.monType.convertItem(texte)
+ else : val = None
listeCol.append(val)
liste.append(listeCol)
self.node.item.setValeur(liste)
--- /dev/null
+import types
+import Accas
+import inspect
+class N_Tuple:
+ def __init__(self,ntuple):
+ self.ntuple=ntuple
+
+ def __convert__(self,valeur):
+ try:
+ if isinstance(valeur, basestring) : return None
+ except NameError:
+ if isinstance(valeur, str): return None
+ if len(valeur) != self.ntuple: return None
+ return valeur
+
+ def info(self):
+ return "Tuple de %s elements" % self.ntuple
+
+class N_Matrice:
+ def __init__(self, nbLigs=None, nbCols=None,
+ methodeCalculTaille=None, formatSortie="ligne",
+ valSup=None, valMin=None, structure=None, typElt='R',
+ typEltInto=None, listeHeaders=None):
+ self.nbLigs = nbLigs
+ self.nbCols = nbCols
+ self.methodeCalculTaille = methodeCalculTaille
+ self.formatSortie = formatSortie
+ self.valSup = valSup
+ self.valMin = valMin
+ self.structure = structure
+ self.typElt = typElt
+ self.listeHeaders = listeHeaders
+ self.typEltInto = typEltInto
+ self.jdc=None
+
+ def __convert__(self, valeur):
+ # Attention ne verifie pas grand chose
+ if not isinstance(valeur, types.ListType):
+ return None
+ return valeur
+
+ def verifItem(self,texte,mc):
+ val=''
+ if self.typElt == 'R' :
+ try : val=float(str(texte)); ok=True
+ except : return (False,"Entrer un float SVP")
+ if self.typElt == 'I' :
+ try : val=int(str(texte)); ok=True
+ except : return (False,"Entrer un float SVP")
+ if self.typElt in ('R', 'I') and self.valSup != None :
+ if val > self.valSup :
+ return (False, "Entrer un nombre inferieur a " + repr(self.valSup))
+ if self.typElt in ('R', 'I') and self.valMin != None :
+ if val < self.valMin :
+ return (False, "Entrer un nombre superieur a " + repr(self.valMin))
+ if val=='' : val = texte
+ if self.typEltInto != None and val not in self.typEltInto :
+ return ( "Entrer une valeur contenue dans " + str(self.typEltInto))
+ try :
+ if issubclass (self.typElt, Accas.ASSD):
+ if not self.jdc : self.jdc = CONTEXT.getCurrentJdC()
+ if not(val in self.jdc.sdsDict.keys()) : return (False, 'Concept inexistant')
+ if not (isinstance(self.jdc.sdsDict[val],self.typElt)) : return (False, 'Concept d un autre type')
+ a=self.jdc.getSdAvantDuBonType(mc.etape,(self.typElt,))
+ if texte not in self.jdc.getSdAvantDuBonType(mc.etape,(self.typElt,)) :
+ return (False, 'Le concept doit etre defini avant')
+ except :
+ pass
+ return ( True, "")
+
+ def convertItem(self,texte):
+ if self.typElt == 'R' : val=float(str(texte))
+ if self.typElt == 'I' : val=int(str(texte))
+ if issubclass (self.typElt, Accas.ASSD): return self.jdc.sdsDict[texte]
+
+
+ def info(self):
+ return "Matrice %s x %s" % (self.nbLigs, self.nbCols)
+
+ __repr__ = info
+ __str__ = info
+
syntaxe python
"""
waitTuple=0
+ waitMatriceDASSD=0
if type(obj.valeur) in (tuple,list) :
s = ''
for ss_type in obj.definition.type:
if repr(ss_type).find('Tuple') != -1 :
waitTuple=1
break
+ if hasattr(ss_type,'typElt'):
+ if ss_type.typElt not in ('TXM','I','R') : waitMatriceDASSD=1
if waitTuple :
#s = str(obj.valeur) +','
#obj.valeurFormatee=obj.valeur
s = obj.getText() +','
obj.valeurFormatee=obj.getText()
+ elif waitMatriceDASSD :
+ s=s+'('
+ for lines in obj.valeur :
+ s=s+'('
+ for elt in lines :
+ s=s+elt.nom+','
+ s=s+'),'
+ s=s+'),'
else :
obj.valeurFormatee=[]
for val in obj.valeur :
s =s +self.formatItem(val,obj.etape,obj,1) + ','
- if obj.waitTxm() :
- obj.valeurFormatee.append(val)
- else :
- obj.valeurFormatee.append(self.formatItem(val,obj.etape,obj))
+ if obj.waitTxm() : obj.valeurFormatee.append(val)
+ else : obj.valeurFormatee.append(self.formatItem(val,obj.etape,obj))
if len(obj.valeur) >= 1:
s = '(' + s + '),'
if obj.valeur==[] or obj.valeur==() : s="(),"
