self.load_appli_composants()
self.listeFichiers=listeFichiers.listeFichiers(self)
self.listePatrons=listePatrons.listePatrons(self)
-
- # PN : ajout d un attribut pour indiquer si
- # l appli a ete lance depuis Salome
- self.salome=0
self.dir=None
# Fermer le splash et deiconifier la fenetre principale si on n'est pas en test
self.initialdir = self.appli.CONFIGURATION.rep_user
self.nb.selectpage(label_onglet)
self.nb.setnaturalsize()
+ self.nb.bind_all("<Key-Next>",lambda e,s=self:s.selectArbreDown())
+ self.nb.bind_all("<Key-Prior>",lambda e,s=self:s.selectArbreUp())
+ self.nb.bind_all("<Insert>",lambda e,s=self:s.deplieReplieNode())
texte = "Jeu de commandes :" + self.JDCName+" ouvert"
CONNECTOR.Connect(JDC,"close",self.onClose,(self.JDCDisplay_courant,))
self.appli.affiche_infos(texte)
if not self.JDC.isvalid():
self.appli.top.update()
self.visuCR(mode='JDC')
- # On a ouvert un Patron
- self.nb.bind_all("<F1>",lambda e,s=self:s.selectArbreDown())
- self.nb.bind_all("<F2>",lambda e,s=self:s.selectArbreUp())
+
+ def deplieReplieNode(self):
+ self.JDCDisplay_courant.tree.tree.deplieReplieNode()
def selectArbreDown(self):
self.JDCDisplay_courant.tree.tree.canvas.focus_set()
veut sauver le JDC
Si echo = 'non' : muet (sauvegarde le JDC dans JDC.procedure)
"""
+ ok = 0
if not hasattr(self,'JDC') : return 0
format=self.appli.format_fichier.get()
if generator.plugins.has_key(format):
self.jdc_fini = string.replace(jdc_formate,'\r\n','\n')
if echo =='oui' or self.JDCDisplay_courant.fichier == None:
- return self.asknomsauvegardeJDC()
+ ok = self.asknomsauvegardeJDC()
elif self.JDCDisplay_courant.fichier != None :
- #PN Ajout --> Salome
- # Pour sauvegarde dans l etude si lancement depuis salome
- if self.appli.salome != 0:
- import eficasEtude
- self.appli.salome.rangeInStudy(self.JDCDisplay_courant.fichier)
- from panelsSalome import SALOME_UNIQUE_BASE_Panel
- if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
- self.appli.salome.creeConfigTxt(self.appli.CONFIGURATION.initialdir,SALOME_UNIQUE_BASE_Panel.dict_fichier_unite)
- #try :
- if ( 1 == 1 ) :
- import eficasCL
- MyCLinit=eficasCL.CLinit()
- MyCLinit.traiteCL()
- MyCLinit.clean()
- #except :
- else :
- pass
- #PN Fin Ajout --> Salome
- # le JDC a déjà un nom : on sauvegarde directement sans demander
- # un autre nom au développeur
- if not save_in_file(self.JDCDisplay_courant.fichier,self.jdc_fini,self.appli.dir) :
+ # le JDC a déjà un nom : on sauvegarde directement sans demander
+ # un autre nom au développeur
+ if not save_in_file(self.JDCDisplay_courant.fichier,self.jdc_fini,self.appli.dir) :
showinfo("Erreur","Problème à la sauvegarde du fichier :" + `self.JDCDisplay_courant.fichier`)
- return 0
- else :
+ #return 0
+ ok = 0
+ else :
if self.appli.format_fichier.get() == 'homard':
self.save_homard(self.JDCDisplay_courant.fichier,self.jdc_homard)
self.JDCDisplay_courant.stop_modif()
self.appli.affiche_infos("sauvegarde de "+`self.JDCDisplay_courant.fichier`+" effectuée")
- return 1
+ ok = 1
+
+ if ok and hasattr( self.appli, 'salome'):
+ # eficas a été lancé à partir deSalome
+ #1)ajout dans l'arbre d'étude du nom du jdc
+ ok, msg = self.appli.addJdcInSalome( self.JDCDisplay_courant.fichier )
+
+ #2)CS_pbruno ??
+ from panelsSalome import SALOME_UNIQUE_BASE_Panel
+ if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
+ print 'CS_pbruno if len(SALOMchier_unite) > 0 :???????'
+ self.appli.creeConfigTxt( self.appli.CONFIGURATION.initialdir, SALOME_UNIQUE_BASE_Panel.dict_fichier_unite )
+
+ #3)création/mise à jours d'un maillage dans Salome
+ self.appli.createOrUpdateMesh()
+ return ok
def asknomsauvegardeJDC(self):
""" Demande à l'utilsateur le nom sous lequel il veut sauvegarder le JDC courant """
#initialdir = self.appli.CONFIGURATION.initialdir)
#initialdir = self.appli.CONFIGURATION.rep_user)
if sauvegarde :
- # PN ajout --> Salome
- # Pour sauvegarde dans l etude si lancement depuis salome
- if self.appli.salome != 0:
- import eficasEtude
- self.appli.salome.rangeInStudy(sauvegarde)
- from panelsSalome import SALOME_UNIQUE_BASE_Panel
- if len(SALOME_UNIQUE_BASE_Panel.dict_fichier_unite) > 0 :
- self.appli.salome.creeConfigTxt(self.appli.CONFIGURATION.initialdir,SALOME_UNIQUE_BASE_Panel.dict_fichier_unite)
- #try :
- if ( 1 == 1 ):
- import eficasCL
- MyCLinit=eficasCL.CLinit()
- MyCLinit.traiteCL()
- MyCLinit.clean()
- #except :
- else :
- pass
- # PN fin ajout --> Salome
if not save_in_file(sauvegarde,self.jdc_fini,None) :
showinfo("Erreur","Problème à la sauvegarde du fichier "+`sauvegarde`)
return 0
f.close()
except:
print "Pb a la sauvegarde sous le format homard"
- if self.appli.salome != 0:
+ if hasattr( self.appli, 'salome'):
import eficasEtude
self.appli.salome.rangeInStudy(file_homard,"_CONF")
#
__version__="$Name: $"
-__Id__="$Id: cataediteur.py,v 1.6 2004/09/20 09:24:13 eficas Exp $"
+__Id__="$Id: cataediteur.py,v 1.7 2005/08/09 09:54:02 eficas Exp $"
#
Fonte_Niveau = fontes.canvas_gras_italique
hull_width = 800,
hull_height = 500,
orient = 'horizontal')
- self.pane.add('canvas',min = 0.4, max = 0.6, size = 0.5)
- self.pane.add('panel',min = 0.4, max = 0.6, size = 0.5)
+ self.pane.add('canvas',min = 0.4, max = 0.6, size = 0.45)
+ self.pane.add('panel',min = 0.4, max = 0.6, size = 0.55)
self.pane.pack(expand =1, fill = 'both')
self.scrolledcanvas = Pmw.ScrolledCanvas(self.pane.pane('canvas'),
hull_width=1.,
Cette classe item dépend bien sûr de la nature de object, d'où
l'interrogation du dictionnaire composants
"""
+
+
if type(object) == types.InstanceType:
# Si la definition de l'objet a un attribut itemeditor, il indique
# la classe a utiliser pour l'item
except:
pass
- # Puis une eventuelle classe heritee (aleatoire car sans ordre)
- for e in composants.keys():
- if isinstance(object,e):
- itemtype= composants[e]
- return itemtype
+ try :
+ for e in composants.keys():
+ if isinstance(object,e):
+ itemtype= composants[e]
+ return itemtype
+ except :
+ pass
+
+ # Puis une eventuelle classe heritee (aleatoire car sans ordre)
+ for e in composants.keys():
+ if isinstance(object,e):
+ itemtype= composants[e]
+ return itemtype
# Apres poum ??? Les lignes suivantes sont elles utiles ?
# Si on n'a rien trouve dans les composants on utilise l'objet par defaut
- print ObjectTreeItem
print itemtype
itemtype=ObjectTreeItem
return itemtype
self.bouton_ann = Button(self.fr_but,text='Annuler',command=self.display_valeur,width=14)
self.bouton_unc = Button(self.fr_but,text='Décommentariser',command=self.uncomment,width=14)
- self.bouton_val.place(relx=0.20,rely=0.5,relheight=0.8,anchor='center')
- self.bouton_ann.place(relx=0.40,rely=0.5,relheight=0.8,anchor='center')
- self.bouton_sup.place(relx=0.60,rely=0.5,relheight=0.8,anchor='center')
- self.bouton_unc.place(relx=0.80,rely=0.5,relheight=0.8,anchor='center')
+ self.bouton_val.place(relx=0.1,rely=0.5,relheight=1,relwidth=0.20,anchor='center')
+ self.bouton_ann.place(relx=0.30,rely=0.5,relheight=1,relwidth=0.20,anchor='center')
+ self.bouton_sup.place(relx=0.50,rely=0.5,relheight=1,relwidth=0.20,anchor='center')
+ self.bouton_unc.place(relx=0.75,rely=0.5,relheight=1,relwidth=0.25,anchor='center')
def change_valeur(self):
"""
nb.add('Commentaire',tab_text='Paramètre/Commentaire')
panneau=Pmw.PanedWidget(nb.page("Mocles"),
orient='horizontal')
- panneau.add('left',min=0.4,max=0.6,size=0.5)
- panneau.add('right',min=0.4,max=0.6,size=0.5)
+ panneau.add('left',min=0.4,max=0.60,size=0.50)
+ panneau.add('right',min=0.4,max=0.60,size=0.50)
panneau.pack(expand=1,fill='both')
+ panneau.setnaturalsize()
self.makeCommandePage(nb.page("Commande"))
self.makeConceptPage_oper(nb.page("Concept"))
self.makeMoclesPage(panneau.pane('left'))
#self.makeCommentairePage(nb.page("Commentaire"))
self.makeParamCommentPage_for_etape(nb.page("Commentaire"))
nb.tab('Mocles').focus_set()
- nb.setnaturalsize()
+ self.nb.setnaturalsize()
self.affiche()
def makeConceptPage_oper(self,page):
commande_comment.jdc = commande_comment.parent = self.object.jdc
pos=self.object.parent.etapes.index(self.object)
- parent= self.object.parent
+ parent=self.object.parent
self.object.parent.suppentite(self.object)
- parent.addentite(commande_comment,pos)
+ addentite(commande_comment,pos)
return commande_comment
#---------------------------------------------------------
# PN ajout pour lancement de Salome
#---------------------------------------------------------
- if self.appli.salome != 0 :
+ if hasattr( self.appli, 'salome' ):
import panelsSalome
self.select_noeud_maille=0
# le dictionnaire sous menu est indexe parceque l'ordre des
# recherches est important
-sous_menu={0:{"3D":"3D.comm"},1:{"pou":"pou.comm"},2:{"divers":"comm"}}
+sous_menu={0:{"3D":"3D.comm"},1:{"poutre":"pou.comm"},2:{"salome":"salome.comm"},3:{"divers":"comm"}}
class listePatrons :
def __init__(self,appli):
self.appli=appli
rep_ini=self.appli.CONFIGURATION.rep_ini
+ if self.appli.code != "ASTER" :
+ return
self.rep_patrons=rep_ini+"/../Editeur/Patrons"
self.liste={}
self.traite_liste()
"""
self.label = Label(page,text='Nom du concept :')
self.label.place(relx=0.1,rely=0.4)
- self.label.bind("<Return>",lambda e,s=self:s.execTutu())
self._any = Entry(page,relief='sunken')
self._any.place(relx=0.35,rely=0.4,relwidth=0.5)
self._any.bind("<Return>",lambda e,s=self:s.execConcept())
from Noyau.N_CR import justify_text
import traceback
-import SalomePyQt
-import salome
+#import SalomePyQt
+import salome # CS_pbruno à poubelliser
import images
-import SMESH_utils
-sgQt=SalomePyQt.SalomePyQt()
+#import SMESH_utils
+#sgQt=SalomePyQt.SalomePyQt()
class SALOME_PLUSIEURS_BASE_Panel(PLUSIEURS_BASE_Panel):
+
+ def __init__(self,parent,panneau,node):
+ PLUSIEURS_BASE_Panel.__init__( self, parent, panneau, node )
+ self.selected_valeur = None
+
+ def add_valeur_plusieurs_base(self,name=None):
+ try:
+ valeur,validite,commentaire=self.get_valeur()
+ #print 'add_valeur_plusieurs_base', name
+ #print 'valeur = %s, validite = %s,commentaire = %s'%( valeur,validite,commentaire )
+ if not valeur: # sélection dans salome
+ #print 'CS_pbruno selection SALOME'
+ strSelection = ''
+
+ selection, msg = self.parent.appli.selectGroupFromSalome()
+
+ #print 'CS_pbruno selection SALOME selection ->',selection
+ #print 'CS_pbruno selection SALOME msg ->',msg
+
+ if selection:
+ for oneSelection in selection:
+ strSelection +=str( oneSelection )
+ strSelection +=','
+
+ strSelection = strSelection.rstrip(',')
+ #print 'CS_pbruno selection SALOME strSelection ->',strSelection
+
+ self.display_valeur( strSelection )
+
+ PLUSIEURS_BASE_Panel.add_valeur_plusieurs_base( self, name )
+ if msg:
+ self.parent.appli.affiche_infos(msg)
+ self.erase_valeur()
+ except:
+ print ' erreur add_valeur_plusieurs_base' #CS_pbruno : afficher boite de dialogue ici ?
+
+ def makeValeurPage(self,page):
+ """
+ Crée la page de saisie d'une liste de valeurs à priori quelconques,
+ cad qui ne sont pas à choisir dans une liste prédéfinie
+ """
+ PLUSIEURS_BASE_Panel.makeValeurPage(self,page)
+ self.c = Button( self.frame_choix, text='Visualiser',command=self.displayInSalomeGeom )
+ self.c.place( relx=0, rely=0.55,relwidth=0.55)
+
+ #self.c.place(relx=0.08,rely=0.55,relwidth=0.35)
+ #self.c.place(relx=0.08,rely=0.55 )
+
+ def displayInSalomeGeom( self ):
+ if self.selected_valeur:
+ ok, msgError = self.parent.appli.displayShape( self.selected_valeur )
+ if not ok:
+ self.parent.appli.affiche_infos(msgError)
+
+
+"""
+class SALOME_PLUSIEURS_BASE_Panel(PLUSIEURS_BASE_Panel):
+
def convertit_group_no_from_salome(self,liste_in):
newr=[]
#try:
def convertit_entrees_en_valeurs(self,entrychaine):
if SALOME_PLUSIEURS_BASE_OR_UNELISTE_Panel.__dict__.has_key(self.clef_fonction):
- valeur=apply(SALOME_PLUSIEURS_BASE_OR_UNELISTE_Panel.__dict__[self.clef_fonction],(self,entrychaine))
+ print 'CS_pbruno AAAAAAAAAAAAA'
+ valeur=apply(SALOME_PLUSIEURS_BASE_OR_UNELISTE_Panel.__dict__[self.clef_fonction],(self,entrychaine))
else :
if (self.clef_fonction.find("GROUP_NO") != -1) and (self.clef_fonction.find("GROUP_MA") != -1) :
+ print 'CS_pbruno BBBBBBBBBBBBBBBBBBB'
if (self.clef_fonction.find("GROUP_NO") < self.clef_fonction.find("GROUP_MA")) :
+ print 'CS_pbruno CCCCCCCCCCCCCCCCCCCCCCCCCC'
valeur=self.convertit_group_maille_from_salome(entrychaine)
else :
+ print 'CS_pbruno DDDDDDDDDDDDDDDDDDDDDDDDD'
valeur=self.convertit_group_no_from_salome(entrychaine)
elif self.clef_fonction.find("GROUP_NO") != -1 :
+ print 'CS_pbruno EEEEEEEEEEEEEEEEEEEEEEEEE'
valeur=self.convertit_group_no_from_salome(entrychaine)
else :
+ print 'CS_pbruno FFFFFFFFFFFFFFFFFFFFFFFF'
if self.clef_fonction.find("GROUP_MA") != -1 :
+ print 'CS_pbruno GGGGGGGGGGGGGGGGGGGGGGGGGGG'
valeur=self.convertit_group_maille_from_salome(entrychaine)
else :
+ print 'CS_pbruno HHHHHHHHHHHHHHHHHHHHHH'
print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
print "Pb pas de fonction de conversion de la valeur Salome en valeur Aster"
print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
return valeur
def sup_valeur_from_salome(self,name=None):
- """
+ #""
Méthode qui sert à retirer de la liste des valeurs la valeur sélectionnée
- """
+ #""
liste_valeurs = self.Liste_valeurs.get_liste()
liste_valeurs_salome=self.Liste_valeurs_salome.get_liste()
entrychaine=salome.sg.getAllSelected()
if i not in liste_valeurs :
liste_valeurs.append(i)
self.Liste_valeurs.put_liste(liste_valeurs)
-
- def add_valeur_from_salome(self,name=None):
+
+
+ def add_valeur_from_salome(self,name=None):
entrychaine=salome.sg.getAllSelected()
self.sortie.delete(0,END)
self.entrygroupe.delete(0,END)
print "impossible d'évaluer %s" %val
self.parent.appli.affiche_infos("Valeur incorrecte : ajout à la liste refusé")
-
+
def makeValeurPage(self,page):
- """
+ #""
Crée la page de saisie d'une liste de valeurs à priori quelconques,
cad qui ne sont pas à choisir dans une liste prédéfinie
- """
+ #""
+
# On récupère la bulle d'aide du panneau, l'objet, l'aide,min et max (cardinalité de la liste),
# et la liste des valeurs déjà affectées à l'objet courant
bulle_aide=self.get_bulle_aide()
for but in (bouton_accepter,bouton_annuler):
but.pack(side='left',padx=5)
+"""
# ------------------------------------------------------------------------------#
#
__version__="$Name: $"
-__Id__="$Id: treewidget.py,v 1.26 2005/11/03 09:03:49 eficas Exp $"
+__Id__="$Id: treewidget.py,v 1.27 2005/11/18 15:58:19 eficas Exp $"
#
Fonte_Standard = fontes.standard
self.item = jdc_item
self.scrolledcanvas = scrolledcanvas
self.canvas = self.scrolledcanvas.component('canvas')
- self.id_up=self.canvas.bind("<Key-Prior>", self.page_up)
- self.id_down=self.canvas.bind("<Key-Next>", self.page_down)
- #self.id_uup=self.canvas.bind("<Key-Up>", self.unit_up)
- #self.id_udown=self.canvas.bind("<Key-Down>", self.unit_down)
+ self.id_up=self.canvas.bind("<F1>", self.page_up)
+ self.id_down=self.canvas.bind("<F2>", self.page_down)
self.id_um=self.canvas.bind("<Key-Left>", self.mot_up)
self.id_dm=self.canvas.bind("<Key-Right>", self.mot_down)
self.id_s=self.canvas.bind("<1>", self.canvas_select)
self.canvas.focus_set()
def mot_up_force(self):
- self.node_selected.select_mot_previous()
+ self.node_selected.select_mot_prev()
self.canvas.focus_set()
+ def deplieReplieNode(self):
+ self.node_selected.deplieReplieNode()
+
def build_children(self):
""" Construit la liste des enfants de self """
self.children = []
#print "supprime",self
self.canvas.unbind("<Key-Prior>",self.id_up)
self.canvas.unbind("<Key-Next>",self.id_down)
- self.canvas.unbind("<Key-Up>",self.id_uup)
- self.canvas.unbind("<Key-Down>",self.id_udown)
self.canvas.unbind("<Key-Left>",self.id_um)
self.canvas.unbind("<Key-Right>",self.id_dm)
self.canvas.unbind("<1>",self.id_s)
self.parent = parent
self.item = item
self.connect()
-
self.command = command
self.rmenu=rmenu
self.tree = self.parent.tree
else :
self.parent.select_next(index)
+ def select_mot_prev(self):
+ index = self.parent.children.index(self) - 1
+ try :
+ if index > -1 :
+ self.parent.children[index].select()
+ if self.parent.children[index].state=="expanded":
+ print len(self.parent.children[index].children)
+ if len(self.parent.children[index].children)!=0 :
+ max=len(self.parent.children[index].children) - 1
+ self.parent.children[index].children[max].select()
+ else :
+ self.parent.children[index].select()
+ else :
+ self.parent.children[index].select()
+ elif self.parent is self.tree:
+ pass
+ else :
+ self.parent.select()
+ except:
+ if self.parent is self.tree:
+ pass
+ else :
+ self.parent.select_previous()
+
+
def select_mot_previous(self):
index = self.parent.children.index(self) - 1
try :
for child in self.children:
child.state='collapsed'
child.collapse_children()
-
+
+ def deplieReplieNode(self):
+ if self.state == 'expanded':
+ self.collapse()
+ else :
+ self.expand_node()
+
def collapse(self,event = None):
""" Collapse self et descendants et retrace self """
nb = self.get_nb_children()
self.zone_texte.pack(side='top',fill='both',expand=1,padx=5,pady=10)
self.zone_texte.configure(yscrollcommand=self.scroll_v.set)
# définition des boutons
- self.but_quit = Button(self.frame_boutons,text = "Fermer",command=self.quit)
+ self.but_quit = Button(self.frame_boutons,text = "Fermer",command=self.quit,default='active')
self.but_save = Button(self.frame_boutons,text = "sauver",command = self.save)
self.but_quit.place(relx=0.4,rely=0.5,anchor='center')
self.but_save.place(relx=0.6,rely=0.5,anchor='center')
--- /dev/null
+from __future__ import division
+import math
+
+def mkf(value):
+ if type(value) in (type(1), type(1L), type(1.5), type(1j),type("hh")):
+ return Constant(value)
+ elif isinstance(value, Formula):
+ return value
+ else:
+ raise TypeError, ("Can't make formula from", value)
+
+class Formula(object):
+ def __complex__(self): return complex(self.eval())
+ def __int__(self): return int(self.eval())
+ def __long__(self): return long(self.eval())
+ def __float__(self): return float(self.eval())
+ def __pos__(self): return self # positive
+ def __neg__(self): return Unop('-', self)
+ def __add__(self, other): return Binop('+', self, other)
+ def __radd__(self, other): return Binop('+', other, self)
+ def __sub__(self, other): return Binop('-', self, other)
+ def __rsub__(self, other): return Binop('-', other, self)
+ def __mul__(self, other): return Binop('*', self, other)
+ def __rmul__(self, other): return Binop('*', other, self)
+ def __div__(self, other): return Binop('/', self, other)
+ def __truediv__(self, other): return Binop('/', self, other)
+ def __rdiv__(self, other): return Binop('/', other, self)
+ def __pow__(self, other): return Binop('**', self, other)
+ def __rpow__(self, other): return Binop('**', other, self)
+ def __getitem__(self,i):return Binop('[]',self,i)
+
+class Binop(Formula):
+ opmap = { '+': lambda a, b: a + b,
+ '*': lambda a, b: a * b,
+ '-': lambda a, b: a - b,
+ '/': lambda a, b: a / b,
+ '**': lambda a, b: a ** b,
+ '[]': lambda a, b: a[b] ,
+ }
+ def __init__(self, op, value1, value2):
+ self.op = op
+ self.values = mkf(value1), mkf(value2)
+ def __str__(self):
+ if self.op == '[]':
+ return "(%s[%s])" % (self.values[0], self.values[1])
+ else:
+ return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
+ def __repr__(self):
+ if self.op == '[]':
+ return "(%s[%s])" % (self.values[0], self.values[1])
+ else:
+ return "(%s %s %s)" % (self.values[0], self.op, self.values[1])
+ def eval(self):
+ result= self.opmap[self.op](self.values[0].eval(),
+ self.values[1].eval())
+ while isinstance(result,Formula):
+ result=result.eval()
+ return result
+
+class Unop(Formula):
+ opmap = { '-': lambda x: -x,
+ 'sin': lambda x: math.sin(x),
+ 'cos': lambda x: math.cos(x) }
+ def __init__(self, op, arg):
+ self._op = op
+ self._arg = mkf(arg)
+ def __str__(self):
+ return "%s(%s)" % (self._op, self._arg)
+ def eval(self):
+ return self.opmap[self._op](self._arg.eval())
+
+class Constant(Formula):
+ def __init__(self, value): self._value = value
+ def eval(self): return self._value
+ def __str__(self): return str(self._value)
+
+def cos(f): return Unop('cos', f)
+def sin(f): return Unop('sin', f)
from Noyau.N_CR import CR
from Noyau import N_OBJECT
from Ihm import I_OBJECT
+from param2 import *
-class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT) :
+class PARAMETRE(N_OBJECT.OBJECT,I_OBJECT.OBJECT,Formula) :
"""
Cette classe permet de créer des objets de type PARAMETRE
cad des affectations directes dans le jeu de commandes (ex: a=10.)
param_item=ITEM_PARAMETRE(self,key)
return param_item
- def __neg__(self):
- try:
- return -1*self.valeur
- except:
- print "******* Probleme : pas de valeur négative"
- return None
+# def __neg__(self):
+# try:
+# return -1*self.valeur
+# except:
+# print "******* Probleme : pas de valeur négative"
+# return None
- def __add__(self,a):
- try :
- return self.valeur+a.valeur
- except :
- print "******* Probleme : a l addition"
- return None
-
- def __radd__(self,a):
- try :
- return self.valeur+a.valeur
- except :
- print "******* Probleme : a l addition"
- return None
-
- def __sub__(self,a):
- try :
- return self.valeur - a.valeur
- except :
- print "******* Probleme : a la soustraction"
- return None
-
- def __rsub__(self,a):
- try :
- return a.valeur - self.valeur
- except :
- print "******* Probleme : a la soustraction"
- return None
-
-
- def __mul__(self,a):
- try :
- return self.valeur*a.valeur
- except :
- print "******* Probleme : a la multiplication"
- return None
-
- def __rmul__(self,a):
- try :
- return self.valeur*a.valeur
- except :
- print "******* Probleme : a la multiplication"
- return None
-
- def __add__(self,other):
- try :
- return self.valeur+other
- except :
- print "******* Probleme : a l addition"
- return None
-
- def __radd__(self,other):
- try :
- return self.valeur+other
- except :
- print "******* Probleme : a l addition"
- return None
-
- def __sub__(self,other):
- try :
- return self.valeur - other
- except :
- print "******* Probleme : a la soustraction"
- return None
-
- def __rsub__(self,other):
- try :
- return other - self.valeur
- except :
- print "******* Probleme : a la soustraction"
- return None
-
- def __mul__ (self,other):
- retour=None
- try :
- retour = eval(self.valeur) * other
- except :
- try :
- retour = self.valeur * other
- except :
- try :
- retour = eval(self.valeur) * eval(other)
- except :
- try :
- retour = self.valeur * eval(other)
- except :
- print other
- print "******* Probleme : a la multiplication _mul__"
- return retour
-
- def __rmul__ (self,other):
- retour=None
- try :
- retour = eval(self.valeur) * other
- except :
- try :
- retour = self.valeur * other
- except :
- try :
- retour = eval(self.valeur) * eval(other)
- except :
- print "******* Probleme : a la multiplication __rmul__"
- return retour
-
-
- def __div__(self,other):
- retour=None
- try:
- retour = eval(self.valeur) / other
- except :
- try :
- retour = self.valeur / other
- except :
- print "******* Probleme : a la division"
- return retour
-
-
- def cos(self):
- try :
- retour=cos(self.valeur)
- return retour
- except:
- print "pb pour cosinus"
-
- def sin(self):
- try :
- retour=sin(self.valeur)
- return retour
- except:
- print "pb pour sinus"
-
- def tan(self):
- try :
- retour=tan(self.valeur)
- return retour
- except:
- print "pb pour tangente"
-
- def log(self):
- try :
- retour=log(self.valeur)
- return retour
- except:
- print "pb pour log"
-
- def sqrt(self):
- try :
- retour=sqrt(self.valeur)
- return retour
- except:
- print "pb pour sqrt"
-
+# def __add__(self,a):
+# try :
+# return self.valeur+a.valeur
+# except :
+# print "******* Probleme : a l addition"
+# return None
+
+# def __radd__(self,a):
+# try :
+# return self.valeur+a.valeur
+# except :
+# print "******* Probleme : a l addition"
+# return None
+
+# def __sub__(self,a):
+# try :
+# return self.valeur - a.valeur
+# except :
+# print "******* Probleme : a la soustraction"
+# return None
+
+# def __rsub__(self,a):
+# try :
+# return a.valeur - self.valeur
+# except :
+# print "******* Probleme : a la soustraction"
+# return None
+
+
+# def __mul__(self,a):
+# try :
+# return self.valeur*a.valeur
+# except :
+# print "******* Probleme : a la multiplication"
+# return None
+
+# def __rmul__(self,a):
+# try :
+# return self.valeur*a.valeur
+# except :
+# print "******* Probleme : a la multiplication"
+# return None
+
+# def __add__(self,other):
+# try :
+# return self.valeur+other
+# except :
+# print "******* Probleme : a l addition"
+# return None
+
+# def __radd__(self,other):
+# try :
+# return self.valeur+other
+# except :
+# print "******* Probleme : a l addition"
+# return None
+
+# def __sub__(self,other):
+# try :
+# return self.valeur - other
+# except :
+# print "******* Probleme : a la soustraction"
+# return None
+
+# def __rsub__(self,other):
+# try :
+# return other - self.valeur
+# except :
+# print "******* Probleme : a la soustraction"
+# return None
+
+# def __mul__ (self,other):
+# retour=None
+# try :
+# retour = eval(self.valeur) * other
+# except :
+# try :
+# retour = self.valeur * other
+# except :
+# try :
+# retour = eval(self.valeur) * eval(other)
+# except :
+# try :
+# retour = self.valeur * eval(other)
+# except :
+# print other
+# print "******* Probleme : a la multiplication _mul__"
+# return retour
+#
+# def __rmul__ (self,other):
+# retour=None
+# try :
+# retour = eval(self.valeur) * other
+# except :
+# try :
+# retour = self.valeur * other
+# except :
+# try :
+# retour = eval(self.valeur) * eval(other)
+# except :
+# print "******* Probleme : a la multiplication __rmul__"
+# return retour
+#
+#
+# def __div__(self,other):
+# retour=None
+# try:
+# retour = eval(self.valeur) / other
+# except :
+# try :
+# retour = self.valeur / other
+# except :
+# print "******* Probleme : a la division"
+# return retour
+#
+#
+# def cos(self):
+# try :
+# retour=cos(self.valeur)
+# return retour
+# except:
+# print "pb pour cosinus"
+#
+# def sin(self):
+# try :
+# retour=sin(self.valeur)
+# return retour
+# except:
+# print "pb pour sinus"
+#
+# def tan(self):
+# try :
+# retour=tan(self.valeur)
+# return retour
+# except:
+# print "pb pour tangente"
+#
+# def log(self):
+# try :
+# retour=log(self.valeur)
+# return retour
+# except:
+# print "pb pour log"
+#
+# def sqrt(self):
+# try :
+# retour=sqrt(self.valeur)
+# return retour
+# except:
+# print "pb pour sqrt"
+#
def interprete_valeur(self,val):
"""
Essaie d'interpréter val (chaîne de caractères)comme :
def reset_context(self):
pass
+ def eval(self):
+ return self.valeur
+
class COMBI_PARAMETRE :
def __init__(self,chainevaleur,valeur):
self.chainevaleur=chainevaleur
itparam=self.cherche_item_parametre(new_valeur)
if itparam:
return itparam,1
+ try :
+ object=eval(new_valeur.valeur,d)
+ except :
+ pass
if CONTEXT.debug : traceback.print_exc()
return None,0
self.jdc.mc_globaux[self.nom]=self
#--------------------------------------------------------------------------------
-# PN : ajout pour Salome des methodes suivantes (jusqu aux méthodes surchargees)
-#--------------------------------------------------------------------------------
- def get_salome_valeurs(self):
- l=[]
- if not hasattr(self,'list_salome_valeurs'):
- self.list_salome_valeurs=[]
- if self.list_salome_valeurs != [] :
- for val in self.list_salome_valeurs:
- l.append(val)
- return l
-
- def put_salome_valeurs(self,list):
- self.list_salome_valeurs=[]
- for val in list:
- self.list_salome_valeurs.append(val)
-
- def add_salome_valeurs(self,val):
- if not hasattr(self,'list_salome_valeurs'):
- self.list_salome_valeurs=[]
- try:
- self.list_salome_valeurs.append(val)
- except :
- try:
- for uneval in val :
- self.list_salome_valeurs.append(uneval)
- except :
- pass
-
- def has_salome_valeurs(self):
- if not hasattr(self,'list_salome_valeurs'):
- self.list_salome_valeurs=[]
- if self.list_salome_valeurs != []:
- return true
- else:
- return false
-
-#--------------------------------------------------------------------------------
-# PN : fin ajout pour Salome
-#--------------------------------------------------------------------------------
#ATTENTION SURCHARGE : toutes les methodes ci apres sont des surcharges du Noyau et de Validation
# Elles doivent etre reintegrees des que possible
return self.valid
+ def verif_typeihm(self,val,cr='non'):
+ try :
+ self.val.eval()
+ return 1
+ except :
+ pass
+ return self.verif_type(val,cr)
+
+ def verif_typeliste(self,val,cr='non') :
+ verif=0
+ for v in val :
+ verif=verif+self.verif_typeihm(v,cr)
+ return verif
+
from Noyau import N_CR
from Noyau.N_utils import repr_float
import Accas
+import Extensions
from Extensions.parametre import ITEM_PARAMETRE
from Formatage import Formatage
if hasattr(obj.etape,'sdprods') and val in obj.etape.sdprods :
s = "CO('"+ self.generator(val) +"')"
elif val.__class__.__name__ == 'CO':
- s = "CO('"+ self.generator(val) +"')"
+ s = "CO('"+ self.generator(val) +"')"
elif isinstance(val,Accas.PARAMETRE):
- # il ne faut pas prendre la string que retourne gener
- # mais seulement le nom dans le cas d'un paramètre
- s = val.nom
+ # il ne faut pas prendre la string que retourne gener
+ # mais seulement le nom dans le cas d'un paramètre
+ s = val.nom
+ elif isinstance(val,Extensions.parametre.PARAMETRE):
+ s = val.nom
else:
- s = self.generator(val)
+ s = self.generator(val)
elif type(val) == types.FloatType :
# Pour un flottant on utilise str
# ou la notation scientifique
pass
else :
# Pour les autres types on utilise repr
- s = `val`
+ if isinstance(val,Extensions.parametre.PARAMETRE):
+ s = val.nom
+ else:
+ s = `val`
s= s + ','
return s
