# -*- coding: utf-8 -*-
+# 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 copy import copy,deepcopy
import traceback
+import typeNode
# Modules Eficas
from Editeur import Objecttreeitem
import browser
from Noyau.N_CR import justify_text
+from Accas import SalomeEntry
-class Node(browser.JDCNode):
+class Node(browser.JDCNode,typeNode.PopUpMenuNodeMinimal):
def getPanel(self):
"""
"""
klass = None
-
# Attention l ordre des if est important
- if self.item.wait_shell():
- # l'objet attend un shell
- # a priori jamais
- print "Pb : Panneau Shell attendu"
- print "Pb : Prevenir la maintenance"
- klass = None #CS_pbruno todo
- return None
+ if self.item.wait_matrice ():
+ from monMatricePanel import MonMatricePanel
+ klass=MonMatricePanel
# l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs
- if self.item.has_into():
+ elif self.item.has_into():
if self.item.is_list() :
from monPlusieursIntoPanel import MonPlusieursIntoPanel
klass = MonPlusieursIntoPanel
# on attend une liste de valeurs
if self.item.is_list() :
# on attend une liste de SD
- if self.item.wait_assd():
+ if self.item.wait_tuple() :
+ from monFonctionPanel import MonFonctionPanel
+ klass = MonFonctionPanel
+ elif self.item.wait_assd():
from monPlusieursASSDPanel import MonPlusieursASSDPanel
klass = MonPlusieursASSDPanel
else:
if self.item.wait_complex():
from monUniqueCompPanel import MonUniqueCompPanel
klass = MonUniqueCompPanel
- else:
- # on attend un entier, un réel ou une string
+ elif self.item.wait_bool() :
+ from monUniqueBoolPanel import MonUniqueBoolPanel
+ klass = MonUniqueBoolPanel
+ else :
from monUniqueBasePanel import MonUniqueBasePanel
klass = MonUniqueBasePanel
return None
return klass( self, self.editor )
-
+
+ def createPopUpMenu(self):
+ typeNode.PopUpMenuNodeMinimal.createPopUpMenu(self)
+
+
+ def getPanelGroupe(self,parentQt,commande):
+ maDefinition=self.item.get_definition()
+ monObjet=self.item.object
+ monNom=self.item.nom
+ maCommande=commande
+
+ # Attention l ordre des if est important
+ # Attention il faut gerer les blocs et les facteurs
+ # a gerer comme dans composimp
+ # Gerer les matrices --> Actuellement pas dans ce type de panneau
+
+ #print "____________________________", self.item.wait_tuple()
+ # Gestion d'une seule valeur (eventuellement un tuple ou un complexe)
+ if maDefinition.max == 1 :
+
+ # Listes de valeur discretes
+ if maDefinition.into != [] and maDefinition.into != None:
+ if len(maDefinition.into) < 4 :
+ from monWidgetRadioButton import MonWidgetRadioButton
+ widget=MonWidgetRadioButton(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ elif len(maDefinition.into) < 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():
+ # Pas fait
+ from monWidgetSimpASSD import MonWidgetSimpASSD
+ widget=MonWidgetSimpASSD(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+
+ elif self.item.wait_Salome() and self.editor.salome:
+ # Pas fait
+ 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:
+ if self.item.is_list_SansOrdreNiDoublon():
+ from monWidgetPlusieursInto import MonWidgetPlusieursInto
+ widget=MonWidgetPlusieursInto(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ from monWidgetPlusieursIntoOrdonne import MonWidgetPlusieursIntoOrdonne
+ widget=MonWidgetPlusieursIntoOrdonne(self,maDefinition,monNom,monObjet,parentQt,maCommande)
+ else :
+ from monWidgetPlusieursBase import MonWidgetPlusieursBase
+ widget=MonWidgetPlusieursBase(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 get_into(self,liste_courante=None):
- # """
- # Cette méthode retourne la liste de choix proposée par le mot cle. Si le mot cle ne propose
- # pas de liste de choix, la méthode retourne None.
- # L'argument d'entrée liste_courante, s'il est différent de None, donne la liste des choix déja
- # effectués par l'utilisateur. Dans ce cas, la méthode get_into doit calculer la liste des choix
- # en en tenant compte.
- # Cette méthode part du principe que la relation entre into du mot clé et les validateurs est
- # une relation de type ET (AndVal).
- # """
- # if not self.object.definition.validators :
- # return self.object.definition.into
- # else:
- # return self.object.definition.validators.get_into(liste_courante,self.definition.into)
+ def is_list_SansOrdreNiDoublon(self):
+ if self.definition.homo=="SansOrdreNiDoublon": 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()
def get_liste_param_possible(self):
liste_param=[]
+ 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)
return "ast-red-ball"
else:
return "ast-yel-ball"
+ print "invalide"
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=""
# wait_geom
# wait_complex
# wait_reel
- # wait_shell
# wait_assd
# GetType
"""
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
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_shell(self):
+ def wait_heure(self):
""" Méthode booléenne qui retourne 1 si l'objet pointé par self
- attend un shell, 0 sinon """
- if 'shell' in self.object.definition.type:
+ 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
+ attend un Tuple, 0 sinon """
+ for ss_type in self.object.definition.type:
+ if repr(ss_type).find('Tuple') != -1 :
+ return 1
+ return 0
+
+ def wait_matrice(self):
+ """ Méthode booléenne qui retourne 1 si l'objet pointé par self
+ attend un Tuple, 0 sinon """
+ for ss_type in self.object.definition.type:
+ if repr(ss_type).find('Matrice') != -1 :
+ return 1
+ return 0
def wait_assd(self):
"""Méthode booléenne qui retourne 1 si l'objet pointé par self
boo = 1
return boo
+ def wait_Salome(self):
+ type = self.object.definition.type[0]
+ if 'grma' in repr(type) : return True
+ if 'grno' in repr(type) : return True
+ if (isinstance(type, types.ClassType) and issubclass(type, SalomeEntry)) : return True
+ return False
def GetType(self):
"""
