-# -*- coding: utf-8 -*-
+# -*- coding: iso-8859-1 -*-
+# Copyright (C) 2007-2013 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
-import string,types,os
+from __future__ import absolute_import
+from __future__ import print_function
+try :
+ from builtins import str
+except : pass
+
+import types,os
from copy import copy,deepcopy
import traceback
-import typeNode
+from . import typeNode
# Modules Eficas
from Editeur import Objecttreeitem
-import browser
+from . import browser
from Noyau.N_CR import justify_text
+from Accas import SalomeEntry
class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
- def getPanel(self):
- """
- """
- klass = None
-
- # Attention l ordre des if est important
- if self.item.wait_matrice ():
- from monMatricePanel import MonMatricePanel
- klass=MonMatricePanel
- # l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
- elif self.item.has_into():
- if self.item.is_list() :
- from monPlusieursIntoPanel import MonPlusieursIntoPanel
- klass = MonPlusieursIntoPanel
- else:
- from monUniqueIntoPanel import MonUniqueIntoPanel
- klass = MonUniqueIntoPanel
-
- # l'objet prend une ou des valeurs a priori quelconques
- else:
- # on attend une liste de valeurs
- if self.item.is_list() :
- # on attend une liste de SD
- if self.item.wait_tuple() :
- from monFonctionPanel import MonFonctionPanel
- klass = MonFonctionPanel
- elif self.item.wait_assd():
- from monPlusieursASSDPanel import MonPlusieursASSDPanel
- klass = MonPlusieursASSDPanel
- else:
- # on attend une liste de valeurs de types debase (entiers, réels,...)
- from monPlusieursBasePanel import MonPlusieursBasePanel
- klass = MonPlusieursBasePanel
- # on n'attend qu'une seule valeur
- else:
- # on attend une SD ou un objet de la classe CO (qui n'existe pas encore)
- if self.item.wait_co():
- if len(self.item.get_sd_avant_du_bon_type()) != 0 :
- from monUniqueSDCOIntoPanel import MonUniqueSDCOIntoPanel
- klass = MonUniqueSDCOIntoPanel
- else :
- from monUniqueSDCOPanel import MonUniqueSDCOPanel
- klass = MonUniqueSDCOPanel
-
- # on attend une SD
- elif self.item.wait_assd():
- if 'R' in self.item.GetType():
- from monUniqueASSDPanel import MonUniqueASSDReelPanel
- klass = MonUniqueASSDReelPanel
- else :
- from monUniqueASSDPanel import MonUniqueASSDPanel
- klass = MonUniqueASSDPanel
-
- # on attend une valeur d'un type de base (entier,reel,...)
- else:
- # on attend un complexe
- if self.item.wait_complex():
- from monUniqueCompPanel import MonUniqueCompPanel
- klass = MonUniqueCompPanel
- else:
- # on attend un entier, un réel ou une string
- from monUniqueBasePanel import MonUniqueBasePanel
- klass = MonUniqueBasePanel
-
- # cas particulier des fonctions
- genea = self.item.get_genealogie()
- if "VALE" in genea or "VALE_C" in genea:
- if "DEFI_FONCTION" in genea :
- from monFonctionPanel import MonFonctionPanel
- klass = MonFonctionPanel
-
- if not klass:
- return None
- return klass( self, self.editor )
-
def createPopUpMenu(self):
typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
-
+
+ def getPanelGroupe(self,parentQt,maCommande):
+ maDefinition=self.item.get_definition()
+ monObjet=self.item.object
+ monNom=self.item.nom
+
+ # label informatif
+ if monObjet.isInformation():
+ from .monWidgetInfo import MonWidgetInfo
+ widget=MonWidgetInfo(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ self.widget=widget
+ return widget
+
+
+ # Attention l ordre des if est important
+ # Attention il faut gerer les blocs et les facteurs
+ # a gerer comme dans composimp
+ # Gestion des matrices
+ if self.item.wait_matrice ():
+ from .monWidgetMatrice import MonWidgetMatrice
+ widget=MonWidgetMatrice(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ self.widget=widget
+ return widget
+
+ #print "____________________________", monNom, self.item.wait_co()
+ #print "____________________________", monNom, self.item.wait_assd()
+ # Gestion d'une seule valeur (eventuellement un tuple ou un complexe)
+ if maDefinition.into != [] and maDefinition.into != None:
+ if type(maDefinition.into) ==types.FunctionType : monInto=maDefinition.into()
+ else : monInto = maDefinition.into
+
+
+ if maDefinition.max == 1 :
+
+ # A verifier
+ if maDefinition.into != [] and maDefinition.into != None:
+ if len(monInto) < 4 :
+ from .monWidgetRadioButton import MonWidgetRadioButton
+ widget=MonWidgetRadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif len(monInto) < 7 :
+ from .monWidget4a6RadioButton import MonWidget4a6RadioButton
+ widget=MonWidget4a6RadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ from .monWidgetCB import MonWidgetCB
+ widget=MonWidgetCB(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+
+ elif self.item.wait_bool() :
+ from .monWidgetSimpBool import MonWidgetSimpBool
+ widget=MonWidgetSimpBool(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif self.item.wait_fichier():
+ from .monWidgetSimpFichier import MonWidgetSimpFichier
+ widget=MonWidgetSimpFichier(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+
+ # PNPNPN - a faire
+ elif self.item.wait_date():
+ from .monWidgetDate import MonWidgetDate
+ widget=MonWidgetDate(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif self.item.wait_heure():
+ from .monWidgetHeure import MonWidgetHeure
+ widget=MonWidgetHeure(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+
+ elif self.item.wait_tuple() :
+ if self.item.object.definition.type[0].ntuple == 2:
+ from .monWidgetSimpTuple2 import MonWidgetSimpTuple2
+ widget=MonWidgetSimpTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif self.item.object.definition.type[0].ntuple == 3 :
+ from .monWidgetSimpTuple3 import MonWidgetSimpTuple3
+ widget=MonWidgetSimpTuple3(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ print ("Pas de Tuple de longueur > 3")
+ print ("Prevenir la maintenance ")
+
+ elif self.item.wait_complex():
+ from .monWidgetSimpComplexe import MonWidgetSimpComplexe
+ widget=MonWidgetSimpComplexe(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+
+ elif self.item.wait_co():
+ if len(self.item.get_sd_avant_du_bon_type()) == 0 :
+ from .monWidgetUniqueSDCO import MonWidgetUniqueSDCO
+ widget=MonWidgetUniqueSDCO(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ from .monWidgetSDCOInto import MonWidgetSDCOInto
+ widget=MonWidgetSDCOInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif self.item.wait_assd():
+ if len(self.item.get_sd_avant_du_bon_type()) == 0 :
+ from .monWidgetVide import MonWidgetVide
+ widget=MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif len(self.item.get_sd_avant_du_bon_type()) < 4 :
+ from .monWidgetRadioButton import MonWidgetRadioButtonSD
+ widget=MonWidgetRadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif len(self.item.get_sd_avant_du_bon_type()) < 7 :
+ from .monWidget4a6RadioButton import MonWidget4a6RadioButtonSD
+ widget=MonWidget4a6RadioButtonSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ from .monWidgetCB import MonWidgetCBSD
+ widget=MonWidgetCBSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+
+ elif self.item.wait_Salome() and self.editor.salome:
+ from .monWidgetSimpSalome import MonWidgetSimpSalome
+ widget=MonWidgetSimpSalome(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+
+ elif self.item.wait_TXM():
+ from .monWidgetSimpTxt import MonWidgetSimpTxt
+ widget=MonWidgetSimpTxt(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ from .monWidgetSimpBase import MonWidgetSimpBase
+ widget=MonWidgetSimpBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+
+ # Gestion des listes
+ else :
+ #if maDefinition.into != [] and maDefinition.into != None:
+ # Attention pas fini --> on attend une liste de ASSD avec ordre
+ if self.item.wait_assd() and self.item.is_list_SansOrdreNiDoublon():
+ #if self.item.is_list_Chargement():
+ #from monWidgetPlusieursTuple2AvecChargement import MonWidgetPlusieursTuple2AvecChargement
+ #widget=MonWidgetPlusieursTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ # pass
+ #else :
+ listeAAfficher = self.item.get_sd_avant_du_bon_type()
+ if len(listeAAfficher) == 0:
+ from .monWidgetVide import MonWidgetVide
+ widget = MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ from .monWidgetPlusieursInto import MonWidgetPlusieursInto
+ widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif self.item.wait_assd() :
+ listeAAfficher = self.item.get_sd_avant_du_bon_type()
+ if len(listeAAfficher) == 0:
+ from .monWidgetVide import MonWidgetVide
+ widget = MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ from .monWidgetPlusieursASSDIntoOrdonne import MonWidgetPlusieursASSDIntoOrdonne
+ widget=MonWidgetPlusieursASSDIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif self.item.wait_tuple() :
+ if self.item.object.definition.type[0].ntuple == 2:
+ from .monWidgetPlusieursTuple2 import MonWidgetPlusieursTuple2
+ widget=MonWidgetPlusieursTuple2(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif self.item.object.definition.type[0].ntuple == 3 :
+ from .monWidgetPlusieursTuple3 import MonWidgetPlusieursTuple3
+ widget=MonWidgetPlusieursTuple3(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ print ("Pas de Tuple de longueur > 3")
+ print ("Prevenir la maintenance ")
+ elif self.item.has_into():
+ if self.item.is_list_SansOrdreNiDoublon():
+
+ if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
+ from .monWidgetPlusieursInto import MonWidgetPlusieursInto
+ widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ from .monWidgetPlusieursPlie import MonWidgetPlusieursPlie
+ widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+# tres vite pour le tag mais devra etre gere dans configuration
+ if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
+ from .monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
+ widget=MonWidgetPlusieursIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ from .monWidgetPlusieursPlie import MonWidgetPlusieursPlie
+ widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ #print 8
+ if self.item in self.editor.listeDesListesOuvertes or not(self.editor.afficheListesPliees) :
+ from .monWidgetPlusieursBase import MonWidgetPlusieursBase
+ widget=MonWidgetPlusieursBase(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ from .monWidgetPlusieursPlie import MonWidgetPlusieursPlie
+ widget=MonWidgetPlusieursPlie(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+
+ self.widget=widget
+ return widget
+
class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem):
itemNode=Node
def is_list(self):
"""
- Cette méthode indique si le mot cle simple attend une liste (valeur de retour 1)
+ Cette methode indique si le mot cle simple attend une liste (valeur de retour 1)
ou s'il n'en attend pas (valeur de retour 0)
Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
- Dans le cas sans validateur, l'information est donnée par l'attribut max
+ Dans le cas sans validateur, l'information est donnee par l'attribut max
de la definition du mot cle.
- Dans le cas avec validateur, il faut combiner l'information précédente avec
- celle issue de l'appel de la méthode is_list sur le validateur.On utilisera
+ Dans le cas avec validateur, il faut combiner l'information precedente avec
+ celle issue de l'appel de la methode is_list sur le validateur.On utilisera
l'operateur ET pour effectuer cette combinaison (AndVal).
"""
is_a_list=0
assert (min <= max)
if max > 1 :
is_a_list=1
- # Dans le cas avec validateurs, pour que le mot cle soit considéré
- # comme acceptant une liste, il faut que max soit supérieur a 1
- # ET que la méthode is_list du validateur retourne 1. Dans les autres cas
+ # Dans le cas avec validateurs, pour que le mot cle soit considere
+ # comme acceptant une liste, il faut que max soit superieur a 1
+ # ET que la methode is_list du validateur retourne 1. Dans les autres cas
# on retournera 0 (n'attend pas de liste)
if self.definition.validators :
is_a_list= self.definition.validators.is_list() * is_a_list
return is_a_list
+ def is_list_SansOrdreNiDoublon(self):
+ if self.definition.homo=="SansOrdreNiDoublon" : return 1
+ return 0
+
+ def is_list_Chargement(self):
+ if self.definition.docu != "" : return 1
+ return 0
def has_into(self):
"""
- Cette méthode indique si le mot cle simple propose un choix (valeur de retour 1)
+ Cette methode indique si le mot cle simple propose un choix (valeur de retour 1)
ou s'il n'en propose pas (valeur de retour 0)
Deux cas principaux peuvent se presenter : avec validateurs ou bien sans.
- Dans le cas sans validateur, l'information est donnée par l'attribut into
+ Dans le cas sans validateur, l'information est donnee par l'attribut into
de la definition du mot cle.
- Dans le cas avec validateurs, pour que le mot cle soit considéré
- comme proposant un choix, il faut que into soit présent OU
- que la méthode has_into du validateur retourne 1. Dans les autres cas
+ Dans le cas avec validateurs, pour que le mot cle soit considere
+ comme proposant un choix, il faut que into soit present OU
+ que la methode has_into du validateur retourne 1. Dans les autres cas
on retournera 0 (ne propose pas de choix)
"""
has_an_into=0
def GetMinMax(self):
- """ Retourne les valeurs min et max de la définition de object """
+ """ Retourne les valeurs min et max de la definition de object """
return self.object.get_min_max()
def GetMultiplicite(self):
- """ A préciser.
- Retourne la multiplicité des valeurs affectées a l'objet
- représenté par l'item. Pour le moment retourne invariablement 1.
+ """ A preciser.
+ Retourne la multiplicite des valeurs affectees a l'objet
+ represente par l'item. Pour le moment retourne invariablement 1.
"""
return 1
def GetIntervalle(self):
"""
- Retourne le domaine de valeur attendu par l'objet représenté
+ Retourne le domaine de valeur attendu par l'objet represente
par l'item.
"""
return self.object.getintervalle()
try :
if "R" in self.object.definition.type:
clef=self.object.GetNomConcept()
- if self.appli.dict_reels.has_key(clef):
- if type(valeurs) == types.TupleType:
+ if clef in self.appli.dict_reels:
+ if type(valeurs) == tuple:
valeurs_reelles=[]
for val in valeurs :
- if self.appli.dict_reels[clef].has_key(val) :
+ if val in self.appli.dict_reels[clef]:
valeurs_reelles.append(self.appli.dict_reels[clef][val])
else :
valeurs_reelles.append(val)
else :
- if self.appli.dict_reels[clef].has_key(valeurs):
+ if valeurs in self.appli.dict_reels[clef]:
valeurs_reelles=self.appli.dict_reels[clef][valeurs]
valeurs=valeurs_reelles
except :
else:
valeurspossibles = self.get_definition().into
+ if listeActuelle==[] : return valeurspossibles
+
#On ne garde que les items valides
listevalideitem=[]
- if type(valeurspossibles) in (types.ListType,types.TupleType) :
+ if type(valeurspossibles) in (list,tuple) :
pass
else :
valeurspossibles=(valeurspossibles,)
encorevalide=self.valide_liste_partielle(item,listeActuelle)
if encorevalide :
listevalideliste.append(item)
+ #print listevalideliste
return listevalideliste
def get_liste_param_possible(self):
liste_param=[]
- print self.object.jdc.params
+ l1,l2=self.jdc.get_parametres_fonctions_avant_etape(self.get_etape())
for param in self.object.jdc.params:
+ if param.nom not in l1 : continue
encorevalide=self.valide_item(param.valeur)
if encorevalide:
type_param=param.valeur.__class__.__name__
def valide_item(self,item):
"""
- La validation est réalisée directement par l'objet
+ La validation est realisee directement par l'objet
"""
return self.object.valide_item(item)
def IsInIntervalle(self,valeur):
"""
Retourne 1 si la valeur est dans l'intervalle permis par
- l'objet représenté par l'item.
+ l'objet represente par l'item.
"""
return self.valide_item(valeur)
def GetText(self):
"""
Classe SIMPTreeItem
- Retourne le texte a afficher dans l'arbre représentant la valeur de l'objet
- pointé par self
+ Retourne le texte a afficher dans l'arbre representant la valeur de l'objet
+ pointe par self
"""
text= self.object.GetText()
if text == None : text=""
"""
return self.object.wait_co()
+ def wait_fichier(self):
+ maDefinition=self.object.definition
+ try :
+ if ('Repertoire' in maDefinition.type[0]) or ('Fichier' in maDefinition.type[0]) :
+ return 1
+ except :
+ return 0
+
def wait_geom(self):
"""
Méthode booléenne qui retourne 1 si l'objet pointé par self
attend un objet GEOM, 0 sinon
"""
return self.object.wait_geom()
+
+ def wait_TXM(self):
+ return self.object.wait_TXM()
+
def wait_complex(self):
""" Méthode booléenne qui retourne 1 si l'objet pointé par self
return 1
else:
return 0
+
+ def wait_date(self):
+ """ Méthode booléenne qui retourne 1 si l'objet pointé par self
+ attend un réel, 0 sinon """
+ if 'DateHHMMAAAA' in self.object.definition.type:
+ return 1
+ else:
+ return 0
+
+ def wait_heure(self):
+ """ Méthode booléenne qui retourne 1 si l'objet pointé par self
+ attend un réel, 0 sinon """
+ if 'HeureHHMMSS' in self.object.definition.type:
+ return 1
+ else:
+ return 0
+
+
def wait_tuple(self):
""" Méthode booléenne qui retourne 1 si l'objet pointé par self
boo = 1
return boo
+ def wait_Salome(self):
+ monType = self.object.definition.type[0]
+ if 'grma' in repr(monType) : return True
+ if 'grno' in repr(monType) : return True
+ try :
+ if issubclass(monType, SalomeEntry) : return True
+ except :
+ pass
+ return False
def GetType(self):
"""
# traite_reel
def eval_valeur(self,valeur):
- """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur de self :
- - retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
- - retourne 'valeur' (chaine de caractéres) sinon
+ """ Lance l'interpretation de 'valeur' (chaine de caracteres) comme valeur de self :
+ - retourne l'objet associe si on a pu interpreter (entier, reel, ASSD,...)
+ - retourne 'valeur' (chaine de caracteres) sinon
"""
newvaleur=self.eval_val(valeur)
return newvaleur,1
def eval_valeur_BAK(self,valeur):
- """ Lance l'interprétation de 'valeur' (chaine de caractéres) comme valeur
+ """ Lance l'interpretation de 'valeur' (chaine de caractéres) comme valeur
de l'objet pointé par self :
- retourne l'objet associé si on a pu interpréter (entier, réel, ASSD,...)
- retourne 'valeur' (chaine de caractéres) sinon
- retourne invalide si 1 des objets du tuple l est
"""
validite=1
- if type(valeur) in (types.ListType,types.TupleType) :
+ if type(valeur) in (list,tuple) :
valeurretour=[]
for item in valeur :
newvaleur,validiteitem=self.eval_valeur_item(item)
#print "eval_valeur_item",valeurretour,validite
if validite == 0:
- if type(valeur) == types.StringType and self.object.wait_TXM():
+ if type(valeur) == bytes and self.object.wait_TXM():
essai_valeur="'" + valeur + "'"
valeurretour,validite= self.object.eval_valeur(essai_valeur)
#validite=0
# on est dans le cas ou on a évalué et ou on n'aurait pas du
if self.object.wait_TXM() :
- if type(valeurretour) != types.StringType:
+ if type(valeurretour) != bytes:
valeurretour=str(valeur)
validite=1
return valeurretour,validite
ou de détecter si on fait référence a un concept produit par DEFI_VALEUR
ou un EVAL ...
"""
- valeur = string.strip(valeur)
+ valeur = valeur.strip()
liste_reels = self.get_sd_avant_du_bon_type()
if valeur in liste_reels:
return valeur
if valeur[0:4] == 'EVAL' :
# on a trouvé un EVAL --> on retourne directement la valeur
return valeur
- if string.find(valeur,'.') == -1 :
+ if valeur.find('.') == -1 :
# aucun '.' n'a été trouvé dans valeur --> on en rajoute un a la fin
if (self.is_param(valeur)):
return valeur
else:
- if string.find(valeur,'e') != -1:
+ if valeur.find('e') != -1:
# Notation scientifique ?
try :
r=eval(valeur)
