1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2010 EDF R&D
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License.
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 # Lesser General Public License for more details.
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
22 This file centralizes the definitions and implementations of ui components used
23 in the GUI part of the module.
26 __author__ = "aribes/gboulant"
29 from PyQt4.QtCore import QObject
30 from PyQt4.QtCore import * # Import from PyQT
31 from PyQt4 import QtGui,QtCore
33 sgPyQt = SalomePyQt.SalomePyQt()
35 from daGuiImpl.enumerate import Enumerate
36 from daGuiImpl.adaoCase import AdaoCase
37 from daEficasWrapper.adaoEficasWrapper import AdaoEficasWrapper
39 from daUtils.adaoEficasEvent import *
41 import adaoStudyEditor
47 # ==============================================================================
48 # Classes to manage the building of UI components
49 # ==============================================================================
51 UI_ELT_IDS = Enumerate([
56 'SAVE_AS_ADAOCASE_ID',
59 'EDIT_ADAOCASE_POP_ID',
64 UI_ELT_IDS.NEW_ADAOCASE_ID:"newAdaoCase",
65 UI_ELT_IDS.OPEN_ADAOCASE_ID:"openAdaoCase",
66 UI_ELT_IDS.SAVE_ADAOCASE_ID:"saveAdaoCase",
67 UI_ELT_IDS.SAVE_AS_ADAOCASE_ID:"saveasAdaoCase",
68 UI_ELT_IDS.CLOSE_ADAOCASE_ID:"closeAdaoCase",
70 UI_ELT_IDS.EDIT_ADAOCASE_POP_ID:"editAdaoCase",
71 UI_ELT_IDS.YACS_EXPORT_POP_ID:"exportCaseToYACS",
75 class AdaoCaseManager(EficasObserver):
77 Cette classe gére les cas ADAO et coordonne les GUI de SALOME (l'étude)
78 et le GUI de l'objet Eficas (héritage du module Eficas)
83 # Création d'un dictionnaire de cas
84 # Key == ref objet editor eficas (on est sur qu'elle est unique, cas duplication)
85 # Value == objet AdaoCase()
88 # Création des deux managers
89 self.salome_manager = AdaoGuiUiComponentBuilder()
90 self.eficas_manager = AdaoEficasWrapper(parent=SalomePyQt.SalomePyQt().getDesktop())
92 # On s'enregistre comme observer pour les évènements venant d'Eficas
93 # Les évènements du salome_manager viennent par le biais de la méthode
95 self.eficas_manager.addObserver(self)
97 # Création du GUI Eficas
98 self.eficas_manager.init_gui()
100 # Création du viewer QT
101 # Scroll Widget (pour les petites résolutions)
102 area = QtGui.QScrollArea(SalomePyQt.SalomePyQt().getDesktop());
103 area.setWidget(self.eficas_manager)
104 area.setWidgetResizable(1)
106 self.eficas_viewId = sgPyQt.createView(wmType, area)
108 # On interdit que la vue soit fermée
109 # Cela simplifier grandement le code
110 sgPyQt.setViewClosable(self.eficas_viewId, False)
112 # On s'abonne au gestionnaire de selection
113 self.selection_manager = sgPyQt.getSelection()
114 QtCore.QObject.connect(self.selection_manager, QtCore.SIGNAL('currentSelectionChanged()'), self.currentSelectionChanged)
118 # Gestion de l'activation/désactivation du module
123 self.eficas_manager.setEnabled(True)
124 sgPyQt.activateView(self.eficas_viewId)
125 self.harmonizeSelectionFromEficas()
127 def deactivate(self):
128 self.eficas_manager.setEnabled(False)
132 # Gestion de la sélection entre le GUI d'Eficas
133 # et l'arbre d'étude de SALOME
137 # Depuis l'étude SALOME
138 def currentSelectionChanged(self):
140 Cette méthode permet de changer le tab vu dans eficas
141 selon la sélection de l'utilisateur dans l'étude SALOME
143 adaoLogger.debug("currentSelectionChanged")
144 salomeStudyItem = adaoGuiHelper.getSelectedItem()
145 for case_editor, adao_case in self.cases.iteritems():
146 if adao_case.salome_study_item.GetID() == salomeStudyItem.GetID():
147 self.eficas_manager.selectCase(adao_case.eficas_editor)
151 def _processEficasTabChanged(self, eficasWrapper, eficasEvent):
153 Gestion de la synchonisation entre le tab courant d'Eficas
154 et la selection dans l'étude SALOME
156 editor = eficasEvent.callbackId
157 for case_editor, adao_case in self.cases.iteritems():
158 if case_editor is editor:
159 adaoGuiHelper.selectItem(adao_case.salome_study_item.GetID())
162 # On remet la sélection dans SALOME grâce au tab dans Eficas
163 def harmonizeSelectionFromEficas(self):
165 Cette méthode permet d'harmoniser la sélection dans l'étude
166 grâce au tab courant d'Eficas
169 # 1: Get current tab index in Eficas
170 editor = self.eficas_manager.getCurrentEditor()
171 # 2: sync with SALOME GUI is a tab is opened
173 for case_editor, adao_case in self.cases.iteritems():
174 if case_editor is editor:
175 adaoGuiHelper.selectItem(adao_case.salome_study_item.GetID())
180 # Gestion de la création d'un nouveau cas
181 # 1: la fonction newAdaoCase est appelée par le GUI SALOME
182 # 2: la fonction _processEficasNewEvent est appelée par le manager EFICAS
186 def newAdaoCase(self):
187 adaoLogger.debug("Création d'un nouveau cas adao")
188 self.eficas_manager.adaofileNew(AdaoCase())
190 def _processEficasNewEvent(self, eficasWrapper, eficasEvent):
191 adao_case = eficasEvent.callbackId
193 salomeStudyId = adaoGuiHelper.getActiveStudyId()
194 salomeStudyItem = adaoStudyEditor.addInStudy(salomeStudyId, adao_case)
195 # Affichage correct dans l'étude
196 adaoGuiHelper.refreshObjectBrowser()
197 adaoGuiHelper.selectItem(salomeStudyItem.GetID())
198 # Finalisation des données du cas
199 adao_case.salome_study_id = salomeStudyId
200 adao_case.salome_study_item = salomeStudyItem
202 self.cases[adao_case.eficas_editor] = adao_case
206 # Gestion de l'ouverture d'un cas
207 # 1: la fonction openAdaoCase est appelée par le GUI SALOME
208 # 2: la fonction _processEficasOpenEvent est appelée par le manager EFICAS
212 # Rq: l'ouverture d'un cas adao est un cas particulier de la création d'un cas adao
214 def openAdaoCase(self):
215 adaoLogger.debug("Ouverture d'un cas adao")
216 self.eficas_manager.adaoFileOpen(AdaoCase())
218 def _processEficasOpenEvent(self, eficasWrapper, eficasEvent):
219 self._processEficasNewEvent(eficasWrapper, eficasEvent)
223 # Gestion de la sauvegarde d'un cas
224 # 1: la fonction saveAdaoCase est appelée par le GUI SALOME
225 # 1 bis: la fonction saveasAdaoCase est appelée par le GUI SALOME
226 # 2: la fonction _processEficasSaveEvent est appelée par le manager EFICAS
230 def saveAdaoCase(self):
231 adaoLogger.debug("Sauvegarde du cas s'il y a modification")
232 # A priori, l'utilisateur s'attend à sauvegarder le cas qui est ouvert
233 # dans le GUI d'Eficas
234 self.harmonizeSelectionFromEficas()
235 salomeStudyItem = adaoGuiHelper.getSelectedItem()
236 for case_name, adao_case in self.cases.iteritems():
237 if adao_case.salome_study_item.GetID() == salomeStudyItem.GetID():
238 self.eficas_manager.adaoFileSave(adao_case)
241 def saveasAdaoCase(self):
242 adaoLogger.debug("Sauvegarde du cas s'il y a modification (version save as)")
243 # A priori, l'utilisateur s'attend à sauvegarder le cas qui est ouvert
244 # dans le GUI d'Eficas
245 self.harmonizeSelectionFromEficas()
246 salomeStudyItem = adaoGuiHelper.getSelectedItem()
247 for case_name, adao_case in self.cases.iteritems():
248 if adao_case.salome_study_item.GetID() == salomeStudyItem.GetID():
249 self.eficas_manager.adaoFileSaveAs(adao_case)
252 def _processEficasSaveEvent(self, eficasWrapper, eficasEvent):
253 adao_case = eficasEvent.callbackId
254 # On met à jour l'étude
255 adaoStudyEditor.updateItem(adao_case.salome_study_id, adao_case.salome_study_item, adao_case)
256 # Affichage correct dans l'étude
257 adaoGuiHelper.refreshObjectBrowser()
258 adaoGuiHelper.selectItem(adao_case.salome_study_item.GetID())
260 self.cases[adao_case.name] = adao_case
264 # Gestion de la fermeture d'un cas
265 # 1: la fonction closeAdaoCase est appelée par le GUI SALOME
266 # 2: la fonction _processEficasCloseEvent est appelée par le manager EFICAS
270 def closeAdaoCase(self):
271 adaoLogger.debug("Fermeture d'un cas")
272 # A priori, l'utilisateur s'attend à sauvegarder le cas qui est ouvert
273 # dans le GUI d'Eficas
274 self.harmonizeSelectionFromEficas()
275 salomeStudyItem = adaoGuiHelper.getSelectedItem()
276 for case_name, adao_case in self.cases.iteritems():
277 if adao_case.salome_study_item.GetID() == salomeStudyItem.GetID():
278 self.eficas_manager.adaoFileClose(adao_case)
281 def _processEficasCloseEvent(self, eficasWrapper, eficasEvent):
282 editor = eficasEvent.callbackId
283 # Recuperation du cas
284 adao_case = self.cases[editor]
285 # Suppression de l'objet dans l'étude
286 adaoStudyEditor.removeItem(adao_case.salome_study_id, adao_case.salome_study_item)
287 adaoGuiHelper.refreshObjectBrowser()
289 del self.cases[editor]
293 # Méthodes secondaires permettant de rediriger les évènements
294 # de SALOME et d'Eficas vers les bonnes méthodes de la classe
298 # Gestion des évènements venant du manager Eficas
300 EficasEvent.EVENT_TYPES.CLOSE : "_processEficasCloseEvent",
301 EficasEvent.EVENT_TYPES.SAVE : "_processEficasSaveEvent",
302 EficasEvent.EVENT_TYPES.NEW : "_processEficasNewEvent",
303 EficasEvent.EVENT_TYPES.CLOSE : "_processEficasCloseEvent",
304 EficasEvent.EVENT_TYPES.OPEN : "_processEficasOpenEvent",
305 EficasEvent.EVENT_TYPES.TABCHANGED : "_processEficasTabChanged",
306 EficasEvent.EVENT_TYPES.REOPEN : "_processEficasReOpenEvent"
309 def processEficasEvent(self, eficasWrapper, eficasEvent):
311 Implementation of the interface EficasObserver. The implementation is a
312 switch on the possible types of events defined in EficasEvent.EVENT_TYPES.
315 functionName = self.__processOptions.get(eficasEvent.eventType, lambda : "_processEficasUnknownEvent")
316 return getattr(self,functionName)(eficasWrapper, eficasEvent)
318 def _processEficasUnknownEvent(self, eficasWrapper, eficasEvent):
319 adaoLogger.error("Unknown Eficas Event")
321 # Gestion des évènements venant du GUI de SALOME
322 def processGUIEvent(self, actionId):
324 Main switch function for ui actions processing
326 if ACTIONS_MAP.has_key(actionId):
328 functionName = ACTIONS_MAP[actionId]
329 getattr(self,functionName)()
331 traceback.print_exc()
333 adaoLogger.warning("The requested action is not implemented: " + str(actionId))
335 class AdaoGuiUiComponentBuilder:
337 The initialisation of this class creates the graphic components involved
338 in the GUI (menu, menu item, toolbar). A ui component builder should be
339 created for each opened study and associated to its context.
342 self.initUiComponents()
344 def initUiComponents(self):
348 # create top-level menu
349 mid = sgPyQt.createMenu( "ADAO", -1, UI_ELT_IDS.ADAO_MENU_ID, sgPyQt.defaultMenuGroup() )
351 tid = sgPyQt.createTool( "ADAO" )
353 a = sgPyQt.createAction( UI_ELT_IDS.NEW_ADAOCASE_ID, "New case", "New case", "Create a new adao case", "" )
354 sgPyQt.createMenu(a, mid)
355 sgPyQt.createTool(a, tid)
356 a = sgPyQt.createAction( UI_ELT_IDS.OPEN_ADAOCASE_ID, "Open case", "Open case", "Open an adao case", "" )
357 sgPyQt.createMenu(a, mid)
358 sgPyQt.createTool(a, tid)
359 a = sgPyQt.createAction( UI_ELT_IDS.SAVE_ADAOCASE_ID, "Save case", "Save case", "Save an adao case", "" )
360 sgPyQt.createMenu(a, mid)
361 sgPyQt.createTool(a, tid)
362 a = sgPyQt.createAction( UI_ELT_IDS.SAVE_AS_ADAOCASE_ID, "Save as case", "Save as case", "Save an adao case as", "" )
363 sgPyQt.createMenu(a, mid)
364 sgPyQt.createTool(a, tid)
365 a = sgPyQt.createAction( UI_ELT_IDS.CLOSE_ADAOCASE_ID, "Close case", "Close case", "Close an adao case", "" )
366 sgPyQt.createMenu(a, mid)
367 sgPyQt.createTool(a, tid)
369 # the following action are used in context popup
370 a = sgPyQt.createAction( UI_ELT_IDS.CLOSE_ADAOCASE_ID, "Close case", "Close case", "Close the selected case", "" )
372 a = sgPyQt.createAction( UI_ELT_IDS.EDIT_ADAOCASE_POP_ID, "Edit case", "Edit case", "Edit the selected study case", "" )
373 a = sgPyQt.createAction( UI_ELT_IDS.YACS_EXPORT_POP_ID, "Export to YACS", "Export to YACS", "Generate a YACS graph executing this case", "" )
375 def createPopupMenuOnItem(self,popup,salomeSudyId, item):
376 if adaoStudyEditor.isValidAdaoCaseItem(salomeSudyId, item):
377 popup.addAction( sgPyQt.action( UI_ELT_IDS.CLOSE_ADAOCASE_ID ) )
379 popup.addAction( sgPyQt.action( UI_ELT_IDS.EDIT_ADAOCASE_POP_ID ) )
380 popup.addAction( sgPyQt.action( UI_ELT_IDS.YACS_EXPORT_POP_ID ) )
384 class AdaoGuiActionImpl(EficasObserver):
386 This class implements the ui actions concerning the management of oma study
392 # This dialog is created once so that it can be recycled for each call
394 #self.__dlgNewStudyCase = DlgNewStudyCase()
395 self.__parent = SalomePyQt.SalomePyQt().getDesktop()
396 self.__dlgEficasWrapper = AdaoEficasWrapper(parent=SalomePyQt.SalomePyQt().getDesktop())
397 self.__dlgEficasWrapper.addObserver(self)
398 self.__Eficas_viewId = -1
400 # ==========================================================================
401 # Processing of ui actions
403 def processAction(self,actionId):
405 Main switch function for ui actions processing
407 if ACTIONS_MAP.has_key(actionId):
409 functionName = ACTIONS_MAP[actionId]
410 getattr(self,functionName)()
412 traceback.print_exc()
414 msg = "The requested action is not implemented: " + str(actionId)
417 def showEficas(self):
418 if self.__Eficas_viewId == -1:
419 self.__dlgEficasWrapper.init_gui()
423 area = QtGui.QScrollArea(SalomePyQt.SalomePyQt().getDesktop());
424 area.setWidget( self.__dlgEficasWrapper)
425 area.setWidgetResizable(1)
428 self.__Eficas_viewId = sgPyQt.createView(wmType, area)
429 sgPyQt.setViewClosable(self.__Eficas_viewId, False)
431 if SalomePyQt.SalomePyQt().getActiveView() != self.__Eficas_viewId :
432 result_activate = SalomePyQt.SalomePyQt().activateView(self.__Eficas_viewId)
433 if result_activate == False:
434 self.__dlgEficasWrapper.init_gui()
437 area = QtGui.QScrollArea(SalomePyQt.SalomePyQt().getDesktop());
438 area.setWidget( self.__dlgEficasWrapper)
439 area.setWidgetResizable(1)
442 self.__Eficas_viewId = sgPyQt.createView(wmType, area)
443 sgPyQt.setViewClosable(self.__Eficas_viewId, False)
444 self.__dlgEficasWrapper.setEnabled(True)
449 def deactivate(self):
451 if self.__Eficas_viewId != -1:
452 self.__dlgEficasWrapper.setEnabled(False)
454 # Actions from SALOME GUI
456 def newAdaoCase(self):
458 adaoLogger.debug("newAdaoCase")
460 self.__dlgEficasWrapper.fileNew()
462 def openAdaoCase(self):
464 adaoLogger.debug("openAdaoCase")
467 fichier = QtGui.QFileDialog.getOpenFileName(SalomePyQt.SalomePyQt().getDesktop(),
468 self.__dlgEficasWrapper.trUtf8('Ouvrir Fichier'),
469 self.__dlgEficasWrapper.CONFIGURATION.savedir,
470 self.__dlgEficasWrapper.trUtf8('JDC Files (*.comm);;''All Files (*)'))
471 if fichier.isNull(): return
472 new_case = AdaoCase()
473 new_case.set_filename(str(fichier))
474 new_case.set_name(str(fichier.split('/')[-1]))
475 salomeStudyId = adaoGuiHelper.getActiveStudyId()
476 salomeStudyItem = adaoStudyEditor.addInStudy(salomeStudyId, new_case)
477 case_key = (salomeStudyId, salomeStudyItem.GetID())
478 __cases__[case_key] = new_case
480 # Open file in Eficas
481 self.__dlgEficasWrapper.Openfile(new_case.get_filename())
482 callbackId = [salomeStudyId, salomeStudyItem]
483 self.__dlgEficasWrapper.setCallbackId(callbackId)
485 adaoGuiHelper.refreshObjectBrowser()
487 def editAdaoCase(self):
489 adaoLogger.debug("editAdaoCase")
493 salomeStudyId = adaoGuiHelper.getActiveStudyId()
494 salomeStudyItem = adaoGuiHelper.getSelectedItem(salomeStudyId)
495 case_key = (salomeStudyId, salomeStudyItem.GetID())
497 # ShowEficas, If case is an empty case - case is destroyed by reopen
500 case = __cases__[case_key]
501 # Search if case is in Eficas !
502 callbackId = [salomeStudyId, salomeStudyItem]
503 case_open_in_eficas = self.__dlgEficasWrapper.selectCase(callbackId)
505 # If case is not in eficas Open It !
506 if case_open_in_eficas == False:
507 if case.get_filename() != "":
508 self.__dlgEficasWrapper.Openfile(case.get_filename())
509 callbackId = [salomeStudyId, salomeStudyItem]
510 self.__dlgEficasWrapper.setCallbackId(callbackId)
512 # Case has been destroyed - create a new one
513 self.__dlgEficasWrapper.fileNew()
515 def closeAdaoCase(self):
517 adaoLogger.debug("closeAdaoCase")
520 # First step: get selected case
521 salomeStudyId = adaoGuiHelper.getActiveStudyId()
522 salomeStudyItem = adaoGuiHelper.getSelectedItem(salomeStudyId)
524 # Check if there is a selected case
525 if salomeStudyItem is None:
526 print "[Close case] Please select a case"
529 callbackId = [salomeStudyId, salomeStudyItem]
530 case_open_in_eficas = self.__dlgEficasWrapper.selectCase(callbackId)
532 # If case is in eficas close it !
533 if case_open_in_eficas:
534 # fileClose: remove the CallbackId
535 # fileClose: sends a destroy event
536 self.__dlgEficasWrapper.fileClose()
538 # Test if case exists
539 case_key = (salomeStudyId, salomeStudyItem.GetID())
540 if __cases__.has_key(case_key):
541 __cases__.pop(case_key)
542 adaoStudyEditor.removeItem(salomeStudyId, salomeStudyItem)
543 adaoGuiHelper.refreshObjectBrowser()
545 def saveAdaoCase(self):
547 adaoLogger.debug("saveAdaoCase")
550 def saveasAdaoCase(self):
552 adaoLogger.debug("saveasAdaoCase")
555 def exportCaseToYACS(self):
557 adaoLogger.debug("exportCaseToYACS")
560 # Get case from study
561 salomeStudyId = adaoGuiHelper.getActiveStudyId()
562 salomeStudyItem = adaoGuiHelper.getSelectedItem(salomeStudyId)
563 case_key = (salomeStudyId, salomeStudyItem.GetID())
564 case = __cases__[case_key]
566 # Generates YACS schema and export it
567 msg = case.exportCaseToYACS()
569 # If msg is not empty -> error found
571 adaoGuiHelper.gui_warning(self.__parent, msg)
573 # ==========================================================================
574 # Processing notifications from adaoEficasWrapper
577 EficasEvent.EVENT_TYPES.CLOSE : "_processEficasCloseEvent",
578 EficasEvent.EVENT_TYPES.SAVE : "_processEficasSaveEvent",
579 EficasEvent.EVENT_TYPES.NEW : "_processEficasNewEvent",
580 EficasEvent.EVENT_TYPES.OPEN : "_processEficasOpenEvent",
581 EficasEvent.EVENT_TYPES.REOPEN : "_processEficasReOpenEvent"
583 def processEficasEvent(self, eficasWrapper, eficasEvent):
585 Implementation of the interface EficasObserver. The implementation is a
586 switch on the possible types of events defined in EficasEvent.EVENT_TYPES.
589 functionName = self.__processOptions.get(eficasEvent.eventType, lambda : "_processEficasUnknownEvent")
590 return getattr(self,functionName)(eficasWrapper, eficasEvent)
592 def _processEficasCloseEvent(self, eficasWrapper, eficasEvent):
595 def _processEficasNewEvent(self, eficasWrapper, eficasEvent):
598 new_case = AdaoCase()
599 case_name = eficasWrapper.getCaseName()
600 new_case.set_name(case_name)
601 salomeStudyId = adaoGuiHelper.getActiveStudyId()
602 salomeStudyItem = adaoStudyEditor.addInStudy(salomeStudyId, new_case)
603 case_key = (salomeStudyId, salomeStudyItem.GetID())
604 __cases__[case_key] = new_case
605 adaoGuiHelper.refreshObjectBrowser()
606 callbackId = [salomeStudyId, salomeStudyItem]
607 self.__dlgEficasWrapper.setCallbackId(callbackId)
609 # We need to select the case
610 adaoGuiHelper.selectItem(salomeStudyItem.GetID())
613 def _processEficasOpenEvent(self, eficasWrapper, eficasEvent):
616 # Ouverture du fichier
617 self.__dlgEficasWrapper.Openfile(self.__dlgEficasWrapper.getOpenFileName())
619 # Creation d'un nouveau cas
620 new_case = AdaoCase()
621 salomeStudyId = adaoGuiHelper.getActiveStudyId()
622 salomeStudyItem = adaoStudyEditor.addInStudy(salomeStudyId, new_case)
623 case_key = (salomeStudyId, salomeStudyItem.GetID())
624 __cases__[case_key] = new_case
626 # Connexion du nouveau cas
627 callbackId = [salomeStudyId, salomeStudyItem]
628 self.__dlgEficasWrapper.setCallbackId(callbackId)
630 # On sauvegarde le cas
631 self._processEficasSaveEvent(self.__dlgEficasWrapper, None, callbackId)
633 def _processEficasSaveEvent(self, eficasWrapper, eficasEvent, callbackId=None):
635 if callbackId is None:
636 callbackId = eficasEvent.callbackId
637 if callbackId is None:
638 raise DevelException("the callback data should not be None. Can't guess what are the study and case")
639 [targetSalomeStudyId,targetSalomeStudyItem] = callbackId
640 if ( targetSalomeStudyId is None ) or ( targetSalomeStudyItem is None ):
641 raise DevelException("the parameters targetSalomeStudyId and targetSalomeStudyItem should not be None")
643 [targetSalomeStudyId,targetSalomeStudyItem] = callbackId
645 # Get Editor All infos we need !
646 case_name = eficasWrapper.getCaseName()
647 file_case_name = eficasWrapper.getFileCaseName()
650 old_case_key = (targetSalomeStudyId, targetSalomeStudyItem.GetID())
651 case =__cases__[old_case_key]
653 # Set new informations
654 case.set_name(case_name)
655 if str(case_name).startswith("Untitled"):
658 case.set_filename(file_case_name)
659 adaoStudyEditor.updateItem(targetSalomeStudyId, targetSalomeStudyItem, case)
662 #new_case_key = (targetSalomeStudyId, targetSalomeStudyItem.GetID())
663 # A ne pas inverser !!!
664 #__cases__.pop(old_case_key)
665 #__cases__[new_case_key] = case
667 adaoGuiHelper.refreshObjectBrowser()
669 def _processEficasDestroyEvent(self, eficasWrapper, eficasEvent):
671 callbackId = eficasEvent.callbackId
672 if callbackId is None:
673 raise DevelException("the callback data should not be None. Can't guess what are the study and case")
674 [targetSalomeStudyId,targetSalomeStudyItem] = callbackId
675 if ( targetSalomeStudyId is None ) or ( targetSalomeStudyItem is None ):
676 raise DevelException("the parameters targetSalomeStudyId and targetSalomeStudyItem should not be None")
678 case_key = (targetSalomeStudyId, targetSalomeStudyItem.GetID())
679 __cases__.pop(case_key)
680 adaoStudyEditor.removeItem(targetSalomeStudyId, targetSalomeStudyItem)
681 adaoGuiHelper.refreshObjectBrowser()
684 # Normalement on ne ferme plus le GUI donc on ne passe plus par là
685 def _processEficasReOpenEvent(self, eficasWrapper, eficasEvent):
687 adaoLogger.warning("_processEficasReOpenEvent")
691 callbackId = eficasEvent.callbackId
692 [salomeStudyId, salomeStudyItem] = callbackId
693 case_key = (salomeStudyId, salomeStudyItem.GetID())
694 case = __cases__[case_key]
695 # Search if case is in Eficas !
696 callbackId = [salomeStudyId, salomeStudyItem]
697 case_open_in_eficas = self.__dlgEficasWrapper.selectCase(callbackId)
698 # If case is not in eficas Open It !
699 if case_open_in_eficas == False:
700 if case.get_filename() != "":
701 self.__dlgEficasWrapper.Openfile(case.get_filename())
702 callbackId = [salomeStudyId, salomeStudyItem]
703 self.__dlgEficasWrapper.setCallbackId(callbackId)
705 # Since I am an empty case I destroy myself before reloading
706 adaoStudyEditor.removeItem(salomeStudyId, salomeStudyItem)
707 adaoGuiHelper.refreshObjectBrowser()
708 __cases__.pop(case_key)
709 callbackId = [salomeStudyId, salomeStudyItem]
710 self.__dlgEficasWrapper.removeCallbackId(callbackId)
712 print "Oups - cannot reopen case !"
713 traceback.print_exc()
715 def _processEficasUnknownEvent(self, eficasWrapper, eficasEvent):
716 print "Unknown Eficas Event"