X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=InterfaceQT4%2Fcomposimp.py;h=6a357912ff463d67b33f865fcf09469f8b966c1f;hb=96176d0080e0d4efbd29d98c0df700a64a82acdc;hp=fb0efe8bc7d6b902097fe5d1ab577e190569d7e6;hpb=d41b1c52d0c35b655f6feabfe816a3c541f3a92a;p=tools%2Feficas.git diff --git a/InterfaceQT4/composimp.py b/InterfaceQT4/composimp.py index fb0efe8b..6a357912 100644 --- a/InterfaceQT4/composimp.py +++ b/InterfaceQT4/composimp.py @@ -1,95 +1,218 @@ -# -*- 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 - - # l'objet prend sa (ses) valeur(s) dans un ensemble discret de valeurs - if 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 - - print klass - 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 @@ -116,14 +239,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 @@ -131,40 +254,33 @@ 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 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 @@ -176,19 +292,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() @@ -199,16 +315,16 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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 : @@ -221,9 +337,11 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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,) @@ -238,11 +356,14 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): encorevalide=self.valide_liste_partielle(item,listeActuelle) if encorevalide : listevalideliste.append(item) + #print listevalideliste return listevalideliste 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__ @@ -272,7 +393,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) @@ -309,7 +430,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) @@ -340,8 +461,8 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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="" @@ -401,12 +522,24 @@ 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 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 @@ -423,15 +556,41 @@ 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_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 - attend un shell, 0 sinon """ + 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 attend un objet de type ASSD ou dérivé, 0 sinon """ @@ -446,6 +605,15 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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): """ @@ -464,15 +632,15 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): # 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 @@ -480,7 +648,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): - 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) @@ -516,7 +684,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): #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) @@ -535,7 +703,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): #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 @@ -570,7 +738,7 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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 @@ -578,12 +746,12 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): 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)