src/daSalome/daGUI/daGuiImpl/adaoGuiManager.py

   1 # -*- coding: utf-8 -*-
   2 #  Copyright (C) 2010 EDF R&D
   3 #
   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.
   8 #
   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.
  13 #
  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
  17 #
  18 #  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 #
  20
  21 """
  22 This file centralizes the definitions and implementations of ui components used
  23 in the GUI part of the module.
  24 """
  25
  26 __author__ = "aribes/gboulant"
  27
  28 import traceback
  29 from PyQt4.QtCore import QObject
  30 from PyQt4.QtCore import *        # Import from PyQT
  31 from PyQt4 import QtGui,QtCore
  32 import SalomePyQt
  33 sgPyQt = SalomePyQt.SalomePyQt()
  34
  35 from daGuiImpl.enumerate import Enumerate
  36 from daGuiImpl.adaoCase import AdaoCase
  37 from daEficasWrapper.adaoEficasWrapper import AdaoEficasWrapper
  38
  39 from daUtils.adaoEficasEvent import *
  40 import adaoGuiHelper
  41 import adaoStudyEditor
  42 import adaoLogger
  43
  44 __cases__ = {}
  45
  46 #
  47 # ==============================================================================
  48 # Classes to manage the building of UI components
  49 # ==============================================================================
  50 #
  51 UI_ELT_IDS = Enumerate([
  52         'ADAO_MENU_ID',
  53         'NEW_ADAOCASE_ID',
  54         'OPEN_ADAOCASE_ID',
  55         'SAVE_ADAOCASE_ID',
  56         'SAVE_AS_ADAOCASE_ID',
  57         'CLOSE_ADAOCASE_ID',
  58
  59         'EDIT_ADAOCASE_POP_ID',
  60         'YACS_EXPORT_POP_ID',
  61         ],offset=6950)
  62
  63 ACTIONS_MAP={
  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",
  69
  70     UI_ELT_IDS.EDIT_ADAOCASE_POP_ID:"editAdaoCase",
  71     UI_ELT_IDS.YACS_EXPORT_POP_ID:"exportCaseToYACS",
  72 }
  73
  74
  75 class AdaoCaseManager(EficasObserver):
  76   """
  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)
  79   """
  80
  81   def __init__(self):
  82
  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()
  86     self.cases = {}
  87
  88     # Création des deux managers
  89     self.salome_manager = AdaoGuiUiComponentBuilder()
  90     self.eficas_manager = AdaoEficasWrapper(parent=SalomePyQt.SalomePyQt().getDesktop())
  91
  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
  94     # processGUIEvent
  95     self.eficas_manager.addObserver(self)
  96
  97     # Création du GUI Eficas
  98     self.eficas_manager.init_gui()
  99
 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)
 105     wmType = "ADAO View"
 106     self.eficas_viewId = sgPyQt.createView(wmType, area)
 107
 108     # On interdit que la vue soit fermée
 109     # Cela simplifier grandement le code
 110     sgPyQt.setViewClosable(self.eficas_viewId, False)
 111
 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)
 115
 116 ######
 117 #
 118 # Gestion de l'activation/désactivation du module
 119 #
 120 ######
 121
 122   def activate(self):
 123     self.eficas_manager.setEnabled(True)
 124     sgPyQt.activateView(self.eficas_viewId)
 125     self.harmonizeSelectionFromEficas()
 126
 127   def deactivate(self):
 128     self.eficas_manager.setEnabled(False)
 129
 130 #######
 131 #
 132 # Gestion de la sélection entre le GUI d'Eficas
 133 # et l'arbre d'étude de SALOME
 134 #
 135 #######
 136
 137   # Depuis l'étude SALOME
 138   def currentSelectionChanged(self):
 139     """
 140     Cette méthode permet de changer le tab vu dans eficas
 141     selon la sélection de l'utilisateur dans l'étude SALOME
 142     """
 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)
 148         break
 149
 150   # Depuis Eficas
 151   def _processEficasTabChanged(self, eficasWrapper, eficasEvent):
 152     """
 153     Gestion de la synchonisation entre le tab courant d'Eficas
 154     et la selection dans l'étude SALOME
 155     """
 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())
 160         break
 161
 162   # On remet la sélection dans SALOME grâce au tab dans Eficas
 163   def harmonizeSelectionFromEficas(self):
 164     """
 165     Cette méthode permet d'harmoniser la sélection dans l'étude
 166     grâce au tab courant d'Eficas
 167     """
 168     if self.cases:
 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
 172       if editor:
 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())
 176             break
 177
 178 #######
 179 #
 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
 183 #
 184 #######
 185
 186   def newAdaoCase(self):
 187     adaoLogger.debug("Création d'un nouveau cas adao")
 188     self.eficas_manager.adaofileNew(AdaoCase())
 189
 190   def _processEficasNewEvent(self, eficasWrapper, eficasEvent):
 191     adao_case = eficasEvent.callbackId
 192     # Ajout dand l'étude
 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
 201     # Ajout du cas
 202     self.cases[adao_case.eficas_editor] = adao_case
 203
 204 #######
 205 #
 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
 209 #
 210 #######
 211
 212 # Rq: l'ouverture d'un cas adao est un cas particulier de la création d'un cas adao
 213
 214   def openAdaoCase(self):
 215     adaoLogger.debug("Ouverture d'un cas adao")
 216     self.eficas_manager.adaoFileOpen(AdaoCase())
 217
 218   def _processEficasOpenEvent(self, eficasWrapper, eficasEvent):
 219     self._processEficasNewEvent(eficasWrapper, eficasEvent)
 220
 221 #######
 222 #
 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
 227 #
 228 #######
 229
 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)
 239         break
 240
 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)
 250         break
 251
 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())
 259     # Ajout du cas
 260     self.cases[adao_case.name] = adao_case
 261
 262 #######
 263 #
 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
 267 #
 268 #######
 269
 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)
 279         break
 280
 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()
 288     # Suppression du cas
 289     del self.cases[editor]
 290
 291 #######
 292 #
 293 # Méthodes secondaires permettant de rediriger les évènements
 294 # de SALOME et d'Eficas vers les bonnes méthodes de la classe
 295 #
 296 #######
 297
 298   # Gestion des évènements venant du manager Eficas
 299   __processOptions={
 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"
 307       }
 308
 309   def processEficasEvent(self, eficasWrapper, eficasEvent):
 310       """
 311       Implementation of the interface EficasObserver. The implementation is a
 312       switch on the possible types of events defined in EficasEvent.EVENT_TYPES.
 313       @overload
 314       """
 315       functionName = self.__processOptions.get(eficasEvent.eventType, lambda : "_processEficasUnknownEvent")
 316       return getattr(self,functionName)(eficasWrapper, eficasEvent)
 317
 318   def _processEficasUnknownEvent(self, eficasWrapper, eficasEvent):
 319     adaoLogger.error("Unknown Eficas Event")
 320
 321   # Gestion des évènements venant du GUI de SALOME
 322   def processGUIEvent(self, actionId):
 323     """
 324     Main switch function for ui actions processing
 325     """
 326     if ACTIONS_MAP.has_key(actionId):
 327       try:
 328           functionName = ACTIONS_MAP[actionId]
 329           getattr(self,functionName)()
 330       except:
 331           traceback.print_exc()
 332     else:
 333       adaoLogger.warning("The requested action is not implemented: " + str(actionId))
 334
 335 class AdaoGuiUiComponentBuilder:
 336     """
 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.
 340     """
 341     def __init__(self):
 342         self.initUiComponents()
 343
 344     def initUiComponents(self):
 345
 346         objectTR = QObject()
 347
 348         # create top-level menu
 349         mid = sgPyQt.createMenu( "ADAO", -1, UI_ELT_IDS.ADAO_MENU_ID, sgPyQt.defaultMenuGroup() )
 350         # create toolbar
 351         tid = sgPyQt.createTool( "ADAO" )
 352
 353         a = sgPyQt.createAction( UI_ELT_IDS.NEW_ADAOCASE_ID, "New case", "New case", "Create a new adao case", "eficas_new.png" )
 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", "eficas_open.png" )
 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", "eficas_save.png" )
 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", "eficas_saveas.png" )
 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", "eficas_close.png" )
 366         sgPyQt.createMenu(a, mid)
 367         sgPyQt.createTool(a, tid)
 368
 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", "" )
 371
 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", "" )
 374
 375     def createPopupMenuOnItem(self,popup,salomeSudyId, item):
 376         if adaoStudyEditor.isValidAdaoCaseItem(salomeSudyId, item):
 377           popup.addAction( sgPyQt.action( UI_ELT_IDS.CLOSE_ADAOCASE_ID ) )
 378
 379           popup.addAction( sgPyQt.action( UI_ELT_IDS.EDIT_ADAOCASE_POP_ID ) )
 380           popup.addAction( sgPyQt.action( UI_ELT_IDS.YACS_EXPORT_POP_ID ) )
 381
 382         return popup
 383
 384 class AdaoGuiActionImpl(EficasObserver):
 385     """
 386     This class implements the ui actions concerning the management of oma study
 387     cases.
 388     """
 389
 390     def __init__(self):
 391         pass
 392         # This dialog is created once so that it can be recycled for each call
 393         # to newOmaCase().
 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
 399
 400     # ==========================================================================
 401     # Processing of ui actions
 402     #
 403     def processAction(self,actionId):
 404         """
 405         Main switch function for ui actions processing
 406         """
 407         if ACTIONS_MAP.has_key(actionId):
 408             try:
 409                 functionName = ACTIONS_MAP[actionId]
 410                 getattr(self,functionName)()
 411             except:
 412                 traceback.print_exc()
 413         else:
 414             msg = "The requested action is not implemented: " + str(actionId)
 415             print msg
 416
 417     def showEficas(self):
 418       if self.__Eficas_viewId == -1:
 419         self.__dlgEficasWrapper.init_gui()
 420
 421
 422         # Scroll Widget
 423         area = QtGui.QScrollArea(SalomePyQt.SalomePyQt().getDesktop());
 424         area.setWidget( self.__dlgEficasWrapper)
 425         area.setWidgetResizable(1)
 426
 427         wmType = "ADAO View"
 428         self.__Eficas_viewId = sgPyQt.createView(wmType, area)
 429         sgPyQt.setViewClosable(self.__Eficas_viewId, False)
 430       else:
 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()
 435
 436             # Scroll Widget
 437             area = QtGui.QScrollArea(SalomePyQt.SalomePyQt().getDesktop());
 438             area.setWidget( self.__dlgEficasWrapper)
 439             area.setWidgetResizable(1)
 440
 441             wmType = "ADAO View"
 442             self.__Eficas_viewId = sgPyQt.createView(wmType, area)
 443             sgPyQt.setViewClosable(self.__Eficas_viewId, False)
 444         self.__dlgEficasWrapper.setEnabled(True)
 445
 446     def activate(self):
 447       self.showEficas()
 448
 449     def deactivate(self):
 450       self.showEficas()
 451       if self.__Eficas_viewId != -1:
 452         self.__dlgEficasWrapper.setEnabled(False)
 453
 454     # Actions from SALOME GUI
 455
 456     def newAdaoCase(self):
 457
 458       adaoLogger.debug("newAdaoCase")
 459       self.showEficas()
 460       self.__dlgEficasWrapper.fileNew()
 461
 462     def openAdaoCase(self):
 463
 464       adaoLogger.debug("openAdaoCase")
 465       self.showEficas()
 466       global __cases__
 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
 479
 480       # Open file in Eficas
 481       self.__dlgEficasWrapper.Openfile(new_case.get_filename())
 482       callbackId = [salomeStudyId, salomeStudyItem]
 483       self.__dlgEficasWrapper.setCallbackId(callbackId)
 484       self.showEficas()
 485       adaoGuiHelper.refreshObjectBrowser()
 486
 487     def editAdaoCase(self):
 488
 489       adaoLogger.debug("editAdaoCase")
 490       global __cases__
 491
 492       # Take study item
 493       salomeStudyId   = adaoGuiHelper.getActiveStudyId()
 494       salomeStudyItem = adaoGuiHelper.getSelectedItem(salomeStudyId)
 495       case_key = (salomeStudyId, salomeStudyItem.GetID())
 496
 497       # ShowEficas, If case is an empty case - case is destroyed by reopen
 498       self.showEficas()
 499       try:
 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)
 504
 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)
 511       except:
 512         # Case has been destroyed - create a new one
 513         self.__dlgEficasWrapper.fileNew()
 514
 515     def closeAdaoCase(self):
 516
 517       adaoLogger.debug("closeAdaoCase")
 518       global __cases__
 519
 520       # First step: get selected case
 521       salomeStudyId   = adaoGuiHelper.getActiveStudyId()
 522       salomeStudyItem = adaoGuiHelper.getSelectedItem(salomeStudyId)
 523
 524       # Check if there is a selected case
 525       if salomeStudyItem is None:
 526         print "[Close case] Please select a case"
 527         return
 528
 529       callbackId = [salomeStudyId, salomeStudyItem]
 530       case_open_in_eficas = self.__dlgEficasWrapper.selectCase(callbackId)
 531
 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()
 537       else:
 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()
 544
 545     def saveAdaoCase(self):
 546
 547       adaoLogger.debug("saveAdaoCase")
 548       global __cases__
 549
 550     def saveasAdaoCase(self):
 551
 552       adaoLogger.debug("saveasAdaoCase")
 553       global __cases__
 554
 555     def exportCaseToYACS(self):
 556
 557       adaoLogger.debug("exportCaseToYACS")
 558       global __cases__
 559
 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]
 565
 566       # Generates YACS schema and export it
 567       msg = case.exportCaseToYACS()
 568
 569       # If msg is not empty -> error found
 570       if msg != "":
 571         adaoGuiHelper.gui_warning(self.__parent, msg)
 572
 573     # ==========================================================================
 574     # Processing notifications from adaoEficasWrapper
 575     #
 576     __processOptions={
 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"
 582         }
 583     def processEficasEvent(self, eficasWrapper, eficasEvent):
 584         """
 585         Implementation of the interface EficasObserver. The implementation is a
 586         switch on the possible types of events defined in EficasEvent.EVENT_TYPES.
 587         @overload
 588         """
 589         functionName = self.__processOptions.get(eficasEvent.eventType, lambda : "_processEficasUnknownEvent")
 590         return getattr(self,functionName)(eficasWrapper, eficasEvent)
 591
 592     def _processEficasCloseEvent(self, eficasWrapper, eficasEvent):
 593         pass
 594
 595     def _processEficasNewEvent(self, eficasWrapper, eficasEvent):
 596       global __cases__
 597
 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)
 608
 609       # We need to select the case
 610       adaoGuiHelper.selectItem(salomeStudyItem.GetID())
 611
 612
 613     def _processEficasOpenEvent(self, eficasWrapper, eficasEvent):
 614       global __cases__
 615
 616       # Ouverture du fichier
 617       self.__dlgEficasWrapper.Openfile(self.__dlgEficasWrapper.getOpenFileName())
 618
 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
 625
 626       # Connexion du nouveau cas
 627       callbackId = [salomeStudyId, salomeStudyItem]
 628       self.__dlgEficasWrapper.setCallbackId(callbackId)
 629
 630       # On sauvegarde le cas
 631       self._processEficasSaveEvent(self.__dlgEficasWrapper, None, callbackId)
 632
 633     def _processEficasSaveEvent(self, eficasWrapper, eficasEvent, callbackId=None):
 634         global __cases__
 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")
 642         else:
 643           [targetSalomeStudyId,targetSalomeStudyItem] = callbackId
 644
 645         # Get Editor All infos we need !
 646         case_name = eficasWrapper.getCaseName()
 647         file_case_name = eficasWrapper.getFileCaseName()
 648         if case_name != "" :
 649           # Get case
 650           old_case_key = (targetSalomeStudyId, targetSalomeStudyItem.GetID())
 651           case =__cases__[old_case_key]
 652
 653           # Set new informations
 654           case.set_name(case_name)
 655           if str(case_name).startswith("Untitled"):
 656             pass
 657           else:
 658             case.set_filename(file_case_name)
 659           adaoStudyEditor.updateItem(targetSalomeStudyId, targetSalomeStudyItem, case)
 660
 661           # Case key changed !
 662           #new_case_key = (targetSalomeStudyId, targetSalomeStudyItem.GetID())
 663           # A ne pas inverser !!!
 664           #__cases__.pop(old_case_key)
 665           #__cases__[new_case_key] = case
 666
 667           adaoGuiHelper.refreshObjectBrowser()
 668
 669     def _processEficasDestroyEvent(self, eficasWrapper, eficasEvent):
 670         global __cases__
 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")
 677
 678         case_key = (targetSalomeStudyId, targetSalomeStudyItem.GetID())
 679         __cases__.pop(case_key)
 680         adaoStudyEditor.removeItem(targetSalomeStudyId, targetSalomeStudyItem)
 681         adaoGuiHelper.refreshObjectBrowser()
 682
 683     # Deprecated
 684     # Normalement on ne ferme plus le GUI donc on ne passe plus par là
 685     def _processEficasReOpenEvent(self, eficasWrapper, eficasEvent):
 686
 687       adaoLogger.warning("_processEficasReOpenEvent")
 688       global __cases__
 689
 690       try:
 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)
 704           else:
 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)
 711       except:
 712         print "Oups - cannot reopen case !"
 713         traceback.print_exc()
 714
 715     def _processEficasUnknownEvent(self, eficasWrapper, eficasEvent):
 716       print "Unknown Eficas Event"