From 3627b084bb31671bb8ae2afe68286770c601c5db Mon Sep 17 00:00:00 2001 From: eficas <> Date: Fri, 6 Feb 2004 16:37:18 +0000 Subject: [PATCH] =?utf8?q?Fusion=20avec=20la=20version=20qui=20tourne=20?= =?utf8?q?=C3=A0=20partir=20de=20salome?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- Editeur/appli.py | 3 + Editeur/bureau.py | 26 ++- Editeur/composimp.py | 22 ++ Editeur/panelsSalome.py | 485 ++++++++++++++++++++++++++++++++++++++++ Ihm/I_MCSIMP.py | 41 ++++ 5 files changed, 573 insertions(+), 4 deletions(-) create mode 100644 Editeur/panelsSalome.py diff --git a/Editeur/appli.py b/Editeur/appli.py index 96f69f2b..8b42dbe1 100644 --- a/Editeur/appli.py +++ b/Editeur/appli.py @@ -66,6 +66,9 @@ class APPLI: except Exception,e : showerror( "ARGUMENT INVALIDE", str(e) ) # AY : fin + # PN : ajout d un attribut pour indiquer si + # l appli a ete lance depuis Salome + self.salome=0 def send_message(self,message): self.message=message diff --git a/Editeur/bureau.py b/Editeur/bureau.py index 82a7e402..e490341d 100644 --- a/Editeur/bureau.py +++ b/Editeur/bureau.py @@ -327,9 +327,9 @@ class BUREAU: """ Sauvegarde le JDC courant. Retourne 1 si la sauvegarde s'est bien faite, 0 sinon. - - Si echo = 'oui' : interactif (l'utilisateur donne le nom sous lequel il + Si echo = 'oui' : interactif (l'utilisateur donne le nom sous lequel il veut sauver le JDC - - Si echo = 'non' : muet (sauvegarde le JDC dans JDC.procedure) + Si echo = 'non' : muet (sauvegarde le JDC dans JDC.procedure) """ if not hasattr(self,'JDC') : return 0 format=self.appli.format_fichier.get() @@ -352,6 +352,15 @@ class BUREAU: if echo =='oui' or self.JDCDisplay_courant.fichier == None: return 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 eficas_etude + 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) + #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) : @@ -377,6 +386,15 @@ class BUREAU: 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 eficas_etude + 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) + # PN fin ajout --> Salome if not save_in_file(sauvegarde,self.jdc_fini) : showinfo("Erreur","Problème à la sauvegarde du fichier "+`sauvegarde`) return 0 @@ -466,7 +484,7 @@ class BUREAU: def visuJDC_py(self): """ Méthode permettant d'afficher dans une fenêtre à part l'écho au - format python du jdc courant + format python du jdc courant """ if not hasattr(self,'JDC') : return jdc_fini = self.get_text_JDC('python') @@ -478,7 +496,7 @@ class BUREAU: def visuJDC(self): """ Méthode permettant d'afficher dans une fenêtre à part l'écho au - format .comm ou .py du jdc courant + format .comm ou .py du jdc courant """ if not hasattr(self,'JDC') : return titre = 'fichier '+ self.JDCName + ' à la syntaxe '+ self.code diff --git a/Editeur/composimp.py b/Editeur/composimp.py index b31d4fef..b242610b 100644 --- a/Editeur/composimp.py +++ b/Editeur/composimp.py @@ -107,6 +107,28 @@ class SIMPTreeItem(Objecttreeitem.AtomicObjectTreeItem): if "VALE" in genea : from fonctionpanel import FONCTION_Panel self.panel=FONCTION_Panel + #--------------------------------------------------------- + # PN ajout pour lancement de Salome + #--------------------------------------------------------- + if self.appli.salome != 0 : + import panelsSalome + + self.clef_fonction="SALOME" + for i in range(0,len( genea )) : + self.clef_fonction=self.clef_fonction+"_"+ genea[i] + + self.select_noeud_maille=0 + if (self.clef_fonction.find("GROUP_NO") != -1) : + self.select_noeud_maille=1 + if (self.clef_fonction.find("GROUP_MA") != -1) : + self.select_noeud_maille=1 + + recherche=panelsSalome.dict_classes_salome[self.panel] + if hasattr(recherche,self.clef_fonction): + self.panel=recherche + if self.select_noeud_maille==1 : + self.panel=recherche + #----------------------------------------------- # diff --git a/Editeur/panelsSalome.py b/Editeur/panelsSalome.py new file mode 100644 index 00000000..e4aa68f9 --- /dev/null +++ b/Editeur/panelsSalome.py @@ -0,0 +1,485 @@ +print "Import de panelsSalome" + +from Tkinter import * +from widgets import ListeChoix +from tkMessageBox import showerror + +from fonctionpanel import FONCTION_Panel +from shellpanel import SHELLPanel +from plusieursintopanel import PLUSIEURS_INTO_Panel +from plusieursassdpanel import PLUSIEURS_ASSD_Panel +from plusieursbasepanel import PLUSIEURS_BASE_Panel +from uniquesdcopanel import UNIQUE_SDCO_Panel +from uniqueassdpanel import UNIQUE_ASSD_Panel +from uniqueintopanel import UNIQUE_INTO_Panel +from uniquecomppanel import UNIQUE_COMP_Panel +from uniquebasepanel import UNIQUE_BASE_Panel + +from Noyau.N_CR import justify_text + +import traceback +import SalomePyQt +import salome +import images +import SMESH_utils +sgQt=SalomePyQt.SalomePyQt() + + + +# 2 types de commandes vont etre particularisees dans Salome +# +# - un cas general : +# Toutes les commandes possedant GROUP_NO ou GROUP_MA +# seront surchargees d office +# pour cela on va utiliser le dictionnaire dict_classes_salome +# qui va permettre de changer la classe de la commande +# ainsi si un panel en dehors de salome a pour classe PLUSIEURS_BASE_Panel +# la classe de ce panel devient alors SALOME_PLUSIEURS_BASE_Panel +# (pour cela voir composimp) + +# des commandes "autres" ne pouvant pas etre identifiées par leur nom +# il suffit de creer dans la classe SALOME de la commande +# une fonction portant son nom +# Exemple de particularisation d un panel : +# Supposons que l on veuille particulariser la commande +# - LIRE_MAILLAGE_UNITE +# le panel initial a pour classe UNIQUE_BASE_Panel +# il suffit d'ajouter dans la classe derivée SALOME_UNIQUE_BASE_Panel +# une fonction SALOME_LIRE_MAILLAGE_UNITE +# la classe de ce panel devient alors SALOME_UNIQUE_BASE_Panel +# on peut surcharger les methodes nécessaires (affichage par exemple) + + +class SALOME_SHELLPanel (SHELLPanel): + "" + +class SALOME_FONCTION_Panel (FONCTION_Panel): + "" + +class SALOME_PLUSIEURS_INTO_Panel (PLUSIEURS_INTO_Panel): + "" + +class SALOME_PLUSIEURS_ASSD_Panel (PLUSIEURS_ASSD_Panel): + "" + +class SALOME_UNIQUE_INTO_Panel (UNIQUE_INTO_Panel): + "" + +class SALOME_UNIQUE_SDCO_Panel (UNIQUE_SDCO_Panel): + "" + +class SALOME_UNIQUE_ASSD_Panel (UNIQUE_ASSD_Panel): + "" + +class SALOME_UNIQUE_COMP_Panel (UNIQUE_COMP_Panel): + "" + +# ------------------------------------------------------------------------------# +# classe SALOME_PLUSIEURS_BASE_Panel +# +# Commandes modifiées : +# - AFFE_CHAR_MECA_DDL_IMPO_GROUP_NO +# Methodes surchargées : +# - makeValeurPage(self,page) +# +# ------------------------------------------------------------------------------# + +class SALOME_PLUSIEURS_BASE_Panel(PLUSIEURS_BASE_Panel): + + + def convertit_group_no_from_salome(self,liste_in): + newr=[] + try: + print liste_in + for entree in liste_in : + travail=[] + travail.append(entree) + entryname_list=SMESH_utils.entryToName(salome.myStudy,travail) + entreeName=entryname_list[0] + if dict_geom_numgroupe.has_key(entreeName): + r=dict_geom_numgroupe[entreeName] + else: + r=SMESH_utils.getAsterGroupNo(salome.myStudy,travail) + dict_geom_numgroupe[entreeName]=r + for i in r : + newr.append(i) + except: + print "pas de groupe de noeuds associé" + showerror("Pas de groupe associé","Cet Objet ne peut pas être défini comme un ensemble de groupe de noeuds") + return newr + + def convertit_group_maille_from_salome(self,liste_in): + newr=[] + try: + print liste_in + for entree in liste_in : + travail=[] + travail.append(entree) + entryname_list=SMESH_utils.entryToName(salome.myStudy,travail) + entreeName=entryname_list[0] + if dict_geom_numgroupe.has_key(entreeName): + r=dict_geom_numgroupe[entreeName] + else: + r=SMESH_utils.getAsterGroupMa(salome.myStudy,travail) + dict_geom_numgroupe[entreeName]=r + for i in r : + newr.append(i) + except: + print "pas de groupe de maille associé" + showerror("Pas de groupe associé","Cet Objet ne peut pas être défini comme un ensemble de groupe de maille") + return newr + + def convertit_entrees_en_valeurs(self,entrychaine): + if SALOME_PLUSIEURS_BASE_Panel.__dict__.has_key(self.clef_fonction): + valeur=apply(SALOME_PLUSIEURS_BASE_Panel.__dict__[self.clef_fonction],(self,entrychaine)) + else : + if self.clef_fonction.find("GROUP_NO") != -1 : + valeur=self.convertit_group_no_from_salome(entrychaine) + else : + if self.clef_fonction.find("GROUP_MA") != -1 : + valeur=self.convertit_group_maille_from_salome(entrychaine) + else : + print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" + print "Pb pas de fonction de conversion de la valeur Salome en valeur Aster" + print "!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" + valeur=[] + print "VALEUR", valeur + 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() + + try: + valeur = self.convertit_entrees_en_valeurs(entrychaine) + for i in valeur : + if i in liste_valeurs : + liste_valeurs.remove(i) + print "enleve" , i + except: + # la valeur sélectionnée n'est pas dans la liste + pass + + entryname_list=SMESH_utils.entryToName(salome.myStudy,entrychaine) + print entryname_list + self.entrygroupe.delete(0,END) + self.sortie.delete(0,END) + for entryname in entryname_list: + try: + liste_valeurs_salome.remove(entryname) + except: + print "la valeur ", entryname, "n est pas dans la liste" + entryname=entryname + " " + self.sortie.insert(0,entryname) + self.selected_valeur = None + self.Liste_valeurs.put_liste(liste_valeurs) + self.Liste_valeurs_salome.put_liste(liste_valeurs_salome) + self.recalcule() + + def recalcule(self): + liste_valeurs_salome=self.Liste_valeurs_salome.get_liste() + groups={} + liste_valeurs = self.Liste_valeurs.get_liste() + for valeur in liste_valeurs_salome: + r=dict_geom_numgroupe[valeur] + for i in r : + 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): + entrychaine=salome.sg.getAllSelected() + self.sortie.delete(0,END) + self.entrygroupe.delete(0,END) + if entrychaine != '': + entryname_list=SMESH_utils.entryToName(salome.myStudy,entrychaine) + touteslesvaleurs = self.convertit_entrees_en_valeurs(entrychaine) + + valeur=[] + liste_valeurs = self.Liste_valeurs.get_liste() + for i in touteslesvaleurs: + if i not in liste_valeurs: + valeur.append(i) + + print valeur + if valeur==[]: + entryname_list=[] + + liste_valeurs_salome = self.Liste_valeurs_salome.get_liste() + for entryname in entryname_list: + if entryname not in liste_valeurs_salome: + liste_valeurs_salome.append(entryname) + entryname=entryname + " " + self.entrygroupe.insert(0,entryname) + self.Liste_valeurs_salome.put_liste(liste_valeurs_salome) + + if self.node.item.wait_reel(): + print "wait_reel()" + valeur = self.traite_reel(valeur) + if self.node.item.wait_geom(): + print "wait_geom()" + val,test1 = valeur,1 + else: + print "else wait" + val,test1 = self.node.item.object.eval_valeur(valeur) + + if test1 : + test2 = self.node.item.object.verif_type(val) + if test2 : + liste_valeurs = self.Liste_valeurs.get_liste() + if len(liste_valeurs) >= max : + self.parent.appli.affiche_infos("La liste a déjà atteint le nombre maximum d'éléments, ajout refusé") + self.erase_valeur() + return + if type(val) == type([]): + for groupe in val: + liste_valeurs.append(groupe) + else: + liste_valeurs.append(val) + self.Liste_valeurs.put_liste(liste_valeurs) + self.parent.appli.affiche_infos("Nouvelle valeur acceptée") + else: + self.parent.appli.affiche_infos("Valeur incorrecte : ajout à la liste refusé") + else: + 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() + objet_mc = self.node.item.get_definition() + aide = self.get_aide() + aide = justify_text(texte=aide) + min,max = self.node.item.GetMinMax() + self.clef_fonction= self.node.item.clef_fonction + l_valeurs = self.node.item.GetListeValeurs() + + self.frame1 = Frame(page,relief='groove',bd=2) + self.frame2 = Frame(page) + self.frame1.place(relx=0.,rely=0.,relwidth=1.,relheight=0.85) + self.frame2.place(relx=0.,rely=0.85,relwidth=1,relheight=0.15) + self.frame_right = Frame(self.frame1) + self.frame_right.place(relx=0.35,rely=0.,relwidth=0.65,relheight=1.) + + # création des frames internes + self.frame_valeurs = Frame(self.frame1) + self.frame_valeurs.place(relx=0.02,rely=0.05,relwidth=0.35,relheight=0.95) + + self.frame_boutons_fleches = Frame(self.frame_right) + self.frame_boutons_fleches.place(relx=0.,rely=0.2,relwidth=0.2,relheight=0.3) + self.frame_choix = Frame(self.frame_right) + self.frame_choix.place(relx=0.2,rely=0.1,relwidth=0.85,relheight=0.9) + self.frame_valeurs_salome = Frame(self.frame_right) + self.frame_valeurs_salome.place(relx=0.02,rely=0.7,relwidth=0.9,relheight=0.3) + + self.frame_boutons = Frame(self.frame2) + self.frame_boutons.place(relx=0.1,rely=0.,relwidth=0.5,relheight=1.) + self.frame_aide = Frame(self.frame2) + self.frame_aide.place(relx=0.6,rely=0.,relwidth=0.5,relheight=1) + + for fram in (self.frame1,self.frame2,self.frame_right,self.frame_valeurs, + self.frame_boutons_fleches,self.frame_choix,self.frame_aide,self.frame_boutons): + fram.bind("",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a)) + fram.bind("",self.parent.appli.efface_aide) + + # création des objets dans les frames + liste_commandes_valeurs = (("",self.selectValeur), + ("",self.deselectValeur), + ("",self.sup_valeur_sans_into)) + self.Liste_valeurs = ListeChoix(self,self.frame_valeurs,l_valeurs, + liste_commandes = liste_commandes_valeurs, + titre="Valeur(s) actuelle(s)") + + self.label = Label(self.frame_choix,text="Valeur :") + self.label.place(relx=0.05,rely=0.4) + # PN : pour ajouter les validators + self.make_entry(frame = self.frame_choix,command = self.add_valeur_plusieurs_base) + + bouton_valeurs_fichier = Button(self.frame_choix, + text="Importer ...", + command=self.select_in_file) + bouton_valeurs_fichier.place(relx=0.28,rely=0.55,relwidth=0.6) + + self.ajout_valeurs = None + self.b = Button(self.frame_choix,text='ajouter selection',command=self.add_valeur_from_salome) + + self.b.place(relx=0.05,rely=0.05) + self.entrygroupe = Entry(self.frame_choix,relief='sunken') + self.entrygroupe.place(relx=0.50,rely=0.05) + + self.a = Button(self.frame_choix,text='enlever selection',command=self.sup_valeur_from_salome) + self.a.place(relx=0.05,rely=0.2) + self.sortie = Entry(self.frame_choix,relief='sunken') + self.sortie.place(relx=0.50,rely=0.2) + + l_salome_valeurs=self.node.item.get_salome_valeurs() + self.Liste_valeurs_salome=ListeChoix(self,self.frame_valeurs_salome,l_salome_valeurs, + liste_commandes = liste_commandes_valeurs, + titre="Valeur(s) Salome actuelle(s) ") + self.Liste_valeurs_salome.affiche_liste() + + + # boutons Ajouter et Supprimer + bouton_add = Button(self.frame_boutons_fleches, + image = images.get_image('arrow_left'), + command = self.add_valeur_plusieurs_base) + bouton_sup = Button(self.frame_boutons_fleches, + image = images.get_image('arrow_right'), + command = self.sup_valeur_sans_into) + bouton_add.place(relx=0.3,rely=0.35) + bouton_sup.place(relx=0.3,rely=0.65) + + # affichage de l'aide + self.frame_aide.update() + self.aide = Label(self.frame_aide, text = aide, + justify='center', anchor='center', + wraplength=int(self.frame_aide.winfo_width()*0.8)) + self.aide.place(relx=0.5,rely=0.5,anchor='center',relwidth=1) + self.Liste_valeurs.affiche_liste() + + # boutons Accepter et Annuler + bouton_accepter = Button(self.frame_boutons, + text='Valider', + command = lambda s=self,m=min,M=max : s.accepte_modifs_valeur(m,M)) + bouton_annuler = Button(self.frame_boutons, + text = 'Annuler', + command = self.annule_modifs_valeur) + for but in (bouton_accepter,bouton_annuler): + but.pack(side='left',padx=5) + + + +# ------------------------------------------------------------------------------# +# classe SALOME_UNIQUE_BASE_Panel +# +# Commandes modifiées : +# - LIRE_MAILLAGE_UNITE +# Methodes surchargées : +# - makeValeurPage(self,page) +# +# ------------------------------------------------------------------------------# + +class SALOME_UNIQUE_BASE_Panel(UNIQUE_BASE_Panel): + +# ce dictionnaire va servir lors de la sortie d efficas +# a creer le fichier qui sera integre au config.txt +# pour relier une unite logique et un nom de fichier + + dict_fichier_unite={} + + def SALOME_LIRE_MAILLAGE_UNITE(self): + + unite=self.node.item.get_valeur() + entrychaine=salome.sg.getAllSelected() + if entrychaine != '': + self.entry2.delete(0,END) + + try: + print salome.myStudy + SO = salome.myStudy.FindObjectID(entrychaine[0]) + print SO + except: + boo = 0 + SO = None + + if SO != None: + myBuilder = salome.myStudy.NewBuilder() + boo,FileAttr = myBuilder.FindAttribute(SO,"AttributeComment") + + if boo == 0 : + FileName='' + print "a" + else : + Comment=FileAttr.Value() + print "ICI" + print Comment + if Comment.find("FICHIERMED")== -1 : + FileName='' + else : + FileName=Comment[10:] + + + print "FileName = " , FileName + if FileName != '' : + print FileName + self.entry2.insert(0,FileName) + typefic='D' + SALOME_UNIQUE_BASE_Panel.dict_fichier_unite[unite]=typefic+FileName + else : + print "il faut afficher une Fenetre d impossibilité" + showerror("Pas de Fichier MED","Cet Objet n a pas de fichier MED Associé") + + def makeValeurPage(self,page): + """ + Génère la page de saisie de la valeur du mot-clé simple courant qui doit être de type + de base cad entier, réel, string ou complexe + """ + # Récupération de l'aide associée au panneau, de l'aide destinée à l'utilisateur, + # et de la liste des SD du bon type (constituant la liste des choix) + bulle_aide=self.get_bulle_aide() + aide=self.get_aide() + aide= justify_text(texte=aide) + liste_noms_sd = self.node.item.get_sd_avant_du_bon_type() + # Remplissage du panneau + self.frame_valeur = Frame(page) + self.frame_valeur.pack(fill='both',expand=1) + self.frame_valeur.bind("",lambda e,s=self,a=bulle_aide : s.parent.appli.affiche_aide(e,a)) + self.frame_valeur.bind("",self.parent.appli.efface_aide) + self.label = Label(self.frame_valeur,text='Valeur :') + self.label.place(relx=0.1,rely=0.5) + self.entry = Entry(self.frame_valeur,relief='sunken') + self.entry.place(relx=0.28,rely=0.5,relwidth=0.6) + self.entry.bind("",lambda e,c=self.valid_valeur:c()) + + # PN : Ajout d'un bouton pour selectionner à partir de Salome + self.b = Button(self.frame_valeur,text='Relier a selection',command=self.SALOME_LIRE_MAILLAGE_UNITE) + self.b.place(relx=0.1,rely=0.1) + unite=self.node.item.get_valeur() + self.entry2 = Entry(self.frame_valeur,relief='sunken') + self.entry2.place(relx=0.3,rely=0.1) + self.entry2.configure(width = 250) + + if SALOME_UNIQUE_BASE_Panel.dict_fichier_unite.has_key(unite): + associe=SALOME_UNIQUE_BASE_Panel.dict_fichier_unite[unite][1:] + self.entry2.delete(0,END) + if associe != "" : + self.entry2.insert(0,associe) + else: + self.entry2.delete(0,END) + + # aide associée au panneau + self.frame_valeur.update() + self.aide = Label(self.frame_valeur, + text = aide, + wraplength=int(self.frame_valeur.winfo_width()*0.8), + justify='center') + self.aide.place(relx=0.5,rely=0.7,anchor='n') + # affichage de la valeur du MCS + self.display_valeur() + +#--------------------------------------------------------------------------------------- +# Correspondances entre les classes eficas et les classes salome_eficas +#______________________________________________________________________________________ +dict_classes_salome = { SHELLPanel : SALOME_SHELLPanel, + FONCTION_Panel : SALOME_FONCTION_Panel, + PLUSIEURS_INTO_Panel : SALOME_PLUSIEURS_INTO_Panel, + PLUSIEURS_ASSD_Panel : SALOME_PLUSIEURS_ASSD_Panel, + PLUSIEURS_BASE_Panel : SALOME_PLUSIEURS_BASE_Panel, + UNIQUE_INTO_Panel : SALOME_UNIQUE_INTO_Panel, + UNIQUE_SDCO_Panel : SALOME_UNIQUE_SDCO_Panel, + UNIQUE_ASSD_Panel : SALOME_UNIQUE_ASSD_Panel, + UNIQUE_COMP_Panel : SALOME_UNIQUE_COMP_Panel, + UNIQUE_BASE_Panel : SALOME_UNIQUE_BASE_Panel} + +dict_geom_numgroupe = { } +dict_geom_numface = { } diff --git a/Ihm/I_MCSIMP.py b/Ihm/I_MCSIMP.py index 2ba38ccb..b897fa06 100644 --- a/Ihm/I_MCSIMP.py +++ b/Ihm/I_MCSIMP.py @@ -335,6 +335,47 @@ class MCSIMP(I_OBJECT.OBJECT): Retourne le type attendu par le mot-clé simple """ return self.definition.type + +#-------------------------------------------------------------------------------- +# 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 -- 2.39.2