X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=InterfaceQT4%2Fcomposimp.py;h=88876b2ddbab357e2a8dec3aa5065776e83f08d8;hb=e570dff249a11579eb7d33de376ed71be16d7261;hp=2d7364fdde2347cfdcbd81421ee532f2ef7b7b55;hpb=69ed0ccae7884aee37bbe54cb1af2983cb51492d;p=tools%2Feficas.git diff --git a/InterfaceQT4/composimp.py b/InterfaceQT4/composimp.py index 2d7364fd..88876b2d 100644 --- a/InterfaceQT4/composimp.py +++ b/InterfaceQT4/composimp.py @@ -1,34 +1,47 @@ # -*- 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 -import prefs - -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 @@ -41,7 +54,10 @@ class Node(browser.JDCNode): # 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: @@ -74,8 +90,10 @@ class Node(browser.JDCNode): 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 @@ -90,7 +108,117 @@ class Node(browser.JDCNode): 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 + + # 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 + # 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_assd(): + if len(self.item.get_sd_avant_du_bon_type()) == 0 : + from monWidgetVide import MonWidgetVide + widget=MonWidgetVide(self,maDefinition,monNom,monObjet,parentQt,maCommande) + if 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: + # 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 @@ -117,14 +245,14 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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 @@ -132,40 +260,29 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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 @@ -177,19 +294,19 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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() @@ -243,7 +360,9 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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__ @@ -273,7 +392,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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) @@ -310,7 +429,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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) @@ -337,12 +456,13 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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="" @@ -391,7 +511,6 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): # wait_geom # wait_complex # wait_reel - # wait_shell # wait_assd # GetType @@ -403,6 +522,14 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): """ 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 @@ -425,14 +552,40 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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 @@ -448,6 +601,12 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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): """