eficas 2.0.3-1-1 / usr / share / pyshared / InterfaceTK / panelsSalome.py

This file is indexed.

/usr/share/pyshared/InterfaceTK/panelsSalome.py is in eficas 2.0.3-1-1.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below. 

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
# -*- coding: utf-8 -*-

from Tkinter import *
from widgets import ListeChoix
from widgets 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 plusieursbasepanel import PLUSIEURS_BASE_OR_UNELISTE_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 uniqueassdpanel    import UNIQUE_ASSD_Panel_Reel

from Noyau.N_CR import justify_text

import traceback
import images



# 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):
        ""

class SALOME_UNIQUE_ASSD_Panel_Reel (UNIQUE_ASSD_Panel_Reel):
        ""

# ------------------------------------------------------------------------------#
# 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_OR_UNELISTE_Panel(PLUSIEURS_BASE_OR_UNELISTE_Panel):
      ""        

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()
        if not valeur: # sélection dans salome        
            strSelection = ''
            
            genea=self.node.item.get_genealogie()
            kwType = None
            for e in genea:
                if "GROUP_NO" in e:
                    kwType = "GROUP_NO"
                if "GROUP_MA" in e:
                    kwType = "GROUP_MA"            
                
            selection, msg = self.parent.appli.selectGroupFromSalome(kwType)
            if selection:
                for oneSelection in selection:
                    strSelection +=str( oneSelection )
                    strSelection +=','
                            
                strSelection = strSelection.rstrip(',')
                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.3, rely=0.0,relwidth=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)
      
      


# ------------------------------------------------------------------------------#
# 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_DONNEES_HOMARD_FICHIER_MED_MAILLAGE_N(self):
      import salome 
      entrychaine=salome.sg.getAllSelected()
      if entrychaine != '':
          self.entry2.delete(0,END)
          try:
              SO = salome.myStudy.FindObjectID(entrychaine[0])
          except:
              boo = 0
              SO = None

          FileName=''
          if SO != None:
              myBuilder = salome.myStudy.NewBuilder()
              boo,FileAttr = myBuilder.FindAttribute(SO,"AttributeFileType")
              if boo:
                 val=FileAttr.Value()
                 if (val !="FICHIERMED" and val != "FICHIER_RESU_MED"):
                     boo=0
                     showerror("Pas de Fichier MED","Cet Objet n a pas de fichier MED Associ\xe9")
                 else:
                     boo,FileAttr = myBuilder.FindAttribute(SO,"AttributeExternalFileDef")
              if boo :
                FileName=FileAttr.Value()
              else:
                 showerror("Pas de Fichier MED","Cet Objet n a pas de fichier MED Associ\xe9")
          if FileName != '' :
              self.entry.delete(0,END)
              self.entry2.delete(0,END)
              self.entry.insert(0,FileName)
              self.entry2.insert(0,FileName)
              self.valid_valeur()


  def SALOME_DONNEES_HOMARD_TRAITEMENT_NOM_MED_MAILLAGE_N(self):
      import salome 
      EntryName=''
      entrychaine=salome.sg.getAllSelected()
      if entrychaine != '':
          self.entry2.delete(0,END)
          try:
              SO = salome.myStudy.FindObjectID(entrychaine[0])
          except:
              boo = 0
              SO = None

          if SO is not None:
             myBuilder = salome.myStudy.NewBuilder()
             ok, AtName = myBuilder.FindAttribute(SO,"AttributeName")
             if ok:
                EntryName=AtName.Value()

      if EntryName != '':
          self.entry.delete(0,END)
          self.entry2.delete(0,END)
          self.entry.insert(0,EntryName)
          self.entry2.insert(0,EntryName)
          self.valid_valeur()

  def SALOME_DONNEES_HOMARD_FICHIER_MED_MAILLAGE_NP1(self):
      self.SALOME_DONNEES_HOMARD_FICHIER_MED_MAILLAGE_N()

  def SALOME_DEFI_GROUP_CREA_GROUP_MA_GROUP_MA(self):
      #try: 
      if ( 1 == 1 ) :
        selection, msg = self.parent.appli.selectGroupFromSalome()
        if selection:
           strSelection =str( selection )
           UNIQUE_BASE_Panel.valid_valeur(self,strSelection)
        if msg:
            self.parent.appli.affiche_infos(msg)
        self.erase_valeur()
      #except:
      else :
        print ' erreur  '
        

  def redistribue_selon_simp(self):
      genea = self.node.item.get_genealogie()
      commande="SALOME"
      for i in range(0,len( genea )) :
        commande=commande+"_"+ genea[i]
      # --------------------------------------------------------------
      # on verifie que la methode n est pas particularise
      # sinon on appelle SALOME_DEFI_GROUP_CREA_GROUP_MA_GROUP_MA qui
      # sert comme methode par defaut 
      # --------------------------------------------------------------
      try :
        SALOME_UNIQUE_BASE_Panel.__dict__[commande](self)
      except :
         SALOME_UNIQUE_BASE_Panel.SALOME_DEFI_GROUP_CREA_GROUP_MA_GROUP_MA(self)



  def makeValeurPage(self,page):
      """
      Crée la page de saisie d'une valeur à priori quelconque,
      cad qui ne sont  pas à choisir dans une liste prédéfinie
      Ajout d'un bouton pour selectionner  à partir de Salome  
      """      
      UNIQUE_BASE_Panel.makeValeurPage(self,page)
      self.b = Button(self.frame_valeur,text='Relier selection',command=self.redistribue_selon_simp)
      self.b.place(relx=0.28,rely=0.4,relwidth=0.4)

#---------------------------------------------------------------------------------------
# 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,
                          PLUSIEURS_BASE_OR_UNELISTE_Panel : SALOME_PLUSIEURS_BASE_OR_UNELISTE_Panel,
                          UNIQUE_INTO_Panel :  SALOME_UNIQUE_INTO_Panel,
                          UNIQUE_SDCO_Panel : SALOME_UNIQUE_SDCO_Panel,
                          UNIQUE_ASSD_Panel : SALOME_UNIQUE_ASSD_Panel,
                          UNIQUE_ASSD_Panel_Reel : SALOME_UNIQUE_ASSD_Panel_Reel,
                          UNIQUE_COMP_Panel : SALOME_UNIQUE_COMP_Panel,
                          UNIQUE_BASE_Panel : SALOME_UNIQUE_BASE_Panel}

dict_geom_numgroupe = { }
dict_geom_numface = { }

APT Browse - Built by Thomas Orozco.