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     self.harmonizeSelectionFromEficas()
 125
 126   def deactivate(self):
 127     self.eficas_manager.setEnabled(False)
 128
 129 #######
 130 #
 131 # Gestion de la sélection entre le GUI d'Eficas
 132 # et l'arbre d'étude de SALOME
 133 #
 134 #######
 135
 136   # Depuis l'étude SALOME
 137   def currentSelectionChanged(self):
 138     """
 139     Cette méthode permet de changer le tab vu dans eficas
 140     selon la sélection de l'utilisateur dans l'étude SALOME
 141     """
 142     adaoLogger.debug("currentSelectionChanged")
 143     salomeStudyItem = adaoGuiHelper.getSelectedItem()
 144     for case_editor, adao_case in self.cases.iteritems():
 145       if adao_case.salome_study_item.GetID() == salomeStudyItem.GetID():
 146         self.eficas_manager.selectCase(adao_case.eficas_editor)
 147         break
 148
 149   # Depuis Eficas
 150   def _processEficasTabChanged(self, eficasWrapper, eficasEvent):
 151     """
 152     Gestion de la synchonisation entre le tab courant d'Eficas
 153     et la selection dans l'étude SALOME
 154     """
 155     editor = eficasEvent.callbackId
 156     for case_editor, adao_case in self.cases.iteritems():
 157       if case_editor is editor:
 158         adaoGuiHelper.selectItem(adao_case.salome_study_item.GetID())
 159         break
 160
 161   # On remet la sélection dans SALOME grâce au tab dans Eficas
 162   def harmonizeSelectionFromEficas(self):
 163     """
 164     Cette méthode permet d'harmoniser la sélection dans l'étude
 165     grâce au tab courant d'Eficas
 166     """
 167     adaoLogger.error("harmonizeSelectionFromEficas NOT YET IMPLEMENTED")
 168     if self.cases:
 169       pass
 170       # 1: Get current tab index in Eficas
 171       # 2: sync with SALOME GUI is a tab is opened
 172
 173 #######
 174 #
 175 # Gestion de la création d'un nouveau cas
 176 # 1: la fonction newAdaoCase est appelée par le GUI SALOME
 177 # 2: la fonction _processEficasNewEvent est appelée par le manager EFICAS
 178 #
 179 #######
 180
 181   def newAdaoCase(self):
 182     adaoLogger.debug("Création d'un nouveau cas adao")
 183     self.eficas_manager.adaofileNew(AdaoCase())
 184
 185   def _processEficasNewEvent(self, eficasWrapper, eficasEvent):
 186     adao_case = eficasEvent.callbackId
 187     # Ajout dand l'étude
 188     salomeStudyId   = adaoGuiHelper.getActiveStudyId()
 189     salomeStudyItem = adaoStudyEditor.addInStudy(salomeStudyId, adao_case)
 190     # Affichage correct dans l'étude
 191     adaoGuiHelper.refreshObjectBrowser()
 192     adaoGuiHelper.selectItem(salomeStudyItem.GetID())
 193     # Finalisation des données du cas
 194     adao_case.salome_study_id   = salomeStudyId
 195     adao_case.salome_study_item = salomeStudyItem
 196     # Ajout du cas
 197     self.cases[adao_case.eficas_editor] = adao_case
 198
 199 #######
 200 #
 201 # Gestion de l'ouverture d'un cas
 202 # 1: la fonction openAdaoCase est appelée par le GUI SALOME
 203 # 2: la fonction _processEficasOpenEvent est appelée par le manager EFICAS
 204 #
 205 #######
 206
 207 # Rq: l'ouverture d'un cas adao est un cas particulier de la création d'un cas adao
 208
 209   def openAdaoCase(self):
 210     adaoLogger.debug("Ouverture d'un cas adao")
 211     self.eficas_manager.adaoFileOpen(AdaoCase())
 212
 213   def _processEficasOpenEvent(self, eficasWrapper, eficasEvent):
 214     self._processEficasNewEvent(eficasWrapper, eficasEvent)
 215
 216 #######
 217 #
 218 # Gestion de la sauvegarde d'un cas
 219 # 1: la fonction saveAdaoCase est appelée par le GUI SALOME
 220 # 1 bis: la fonction saveasAdaoCase est appelée par le GUI SALOME
 221 # 2: la fonction _processEficasSaveEvent est appelée par le manager EFICAS
 222 #
 223 #######
 224
 225   def saveAdaoCase(self):
 226     adaoLogger.debug("Sauvegarde du cas s'il y a modification")
 227     # A priori, l'utilisateur s'attend à sauvegarder le cas qui est ouvert
 228     # dans le GUI d'Eficas
 229     self.harmonizeSelectionFromEficas()
 230     salomeStudyItem = adaoGuiHelper.getSelectedItem()
 231     for case_name, adao_case in self.cases.iteritems():
 232       if adao_case.salome_study_item.GetID() == salomeStudyItem.GetID():
 233         self.eficas_manager.adaoFileSave(adao_case)
 234         break
 235
 236   def saveasAdaoCase(self):
 237     adaoLogger.debug("Sauvegarde du cas s'il y a modification (version save as)")
 238     # A priori, l'utilisateur s'attend à sauvegarder le cas qui est ouvert
 239     # dans le GUI d'Eficas
 240     self.harmonizeSelectionFromEficas()
 241     salomeStudyItem = adaoGuiHelper.getSelectedItem()
 242     for case_name, adao_case in self.cases.iteritems():
 243       if adao_case.salome_study_item.GetID() == salomeStudyItem.GetID():
 244         self.eficas_manager.adaoFileSaveAs(adao_case)
 245         break
 246
 247   def _processEficasSaveEvent(self, eficasWrapper, eficasEvent):
 248     adao_case = eficasEvent.callbackId
 249     # On met à jour l'étude
 250     adaoStudyEditor.updateItem(adao_case.salome_study_id, adao_case.salome_study_item, adao_case)
 251     # Affichage correct dans l'étude
 252     adaoGuiHelper.refreshObjectBrowser()
 253     adaoGuiHelper.selectItem(adao_case.salome_study_item.GetID())
 254     # Ajout du cas
 255     self.cases[adao_case.name] = adao_case
 256
 257 #######
 258 #
 259 # Gestion de la fermeture d'un cas
 260 # 1: la fonction closeAdaoCase est appelée par le GUI SALOME
 261 # 2: la fonction _processEficasCloseEvent est appelée par le manager EFICAS
 262 #
 263 #######
 264
 265   def closeAdaoCase(self):
 266     adaoLogger.debug("Fermeture d'un cas")
 267     # A priori, l'utilisateur s'attend à sauvegarder le cas qui est ouvert
 268     # dans le GUI d'Eficas
 269     self.harmonizeSelectionFromEficas()
 270     salomeStudyItem = adaoGuiHelper.getSelectedItem()
 271     for case_name, adao_case in self.cases.iteritems():
 272       if adao_case.salome_study_item.GetID() == salomeStudyItem.GetID():
 273         self.eficas_manager.adaoFileClose(adao_case)
 274         break
 275
 276   def _processEficasCloseEvent(self, eficasWrapper, eficasEvent):
 277     editor = eficasEvent.callbackId
 278     # Recuperation du cas
 279     adao_case = self.cases[editor]
 280     # Suppression de l'objet dans l'étude
 281     adaoStudyEditor.removeItem(adao_case.salome_study_id, adao_case.salome_study_item)
 282     adaoGuiHelper.refreshObjectBrowser()
 283     # Suppression du cas
 284     del self.cases[editor]
 285
 286 #######
 287 #
 288 # Méthodes secondaires permettant de rediriger les évènements
 289 # de SALOME et d'Eficas vers les bonnes méthodes de la classe
 290 #
 291 #######
 292
 293   # Gestion des évènements venant du manager Eficas
 294   __processOptions={
 295       EficasEvent.EVENT_TYPES.CLOSE      : "_processEficasCloseEvent",
 296       EficasEvent.EVENT_TYPES.SAVE       : "_processEficasSaveEvent",
 297       EficasEvent.EVENT_TYPES.NEW        : "_processEficasNewEvent",
 298       EficasEvent.EVENT_TYPES.CLOSE      : "_processEficasCloseEvent",
 299       EficasEvent.EVENT_TYPES.OPEN       : "_processEficasOpenEvent",
 300       EficasEvent.EVENT_TYPES.TABCHANGED : "_processEficasTabChanged",
 301       EficasEvent.EVENT_TYPES.REOPEN     : "_processEficasReOpenEvent"
 302       }
 303
 304   def processEficasEvent(self, eficasWrapper, eficasEvent):
 305       """
 306       Implementation of the interface EficasObserver. The implementation is a
 307       switch on the possible types of events defined in EficasEvent.EVENT_TYPES.
 308       @overload
 309       """
 310       functionName = self.__processOptions.get(eficasEvent.eventType, lambda : "_processEficasUnknownEvent")
 311       return getattr(self,functionName)(eficasWrapper, eficasEvent)
 312
 313   def _processEficasUnknownEvent(self, eficasWrapper, eficasEvent):
 314     adaoLogger.error("Unknown Eficas Event")
 315
 316   # Gestion des évènements venant du GUI de SALOME
 317   def processGUIEvent(self, actionId):
 318     """
 319     Main switch function for ui actions processing
 320     """
 321     if ACTIONS_MAP.has_key(actionId):
 322       try:
 323           functionName = ACTIONS_MAP[actionId]
 324           getattr(self,functionName)()
 325       except:
 326           traceback.print_exc()
 327     else:
 328       adaoLogger.warning("The requested action is not implemented: " + str(actionId))
 329
 330 class AdaoGuiUiComponentBuilder:
 331     """
 332     The initialisation of this class creates the graphic components involved
 333     in the GUI (menu, menu item, toolbar). A ui component builder should be
 334     created for each opened study and associated to its context.
 335     """
 336     def __init__(self):
 337         self.initUiComponents()
 338
 339     def initUiComponents(self):
 340
 341         objectTR = QObject()
 342
 343         # create top-level menu
 344         mid = sgPyQt.createMenu( "ADAO", -1, UI_ELT_IDS.ADAO_MENU_ID, sgPyQt.defaultMenuGroup() )
 345         # create toolbar
 346         tid = sgPyQt.createTool( "ADAO" )
 347
 348         a = sgPyQt.createAction( UI_ELT_IDS.NEW_ADAOCASE_ID, "New case", "New case", "Create a new adao case", "" )
 349         sgPyQt.createMenu(a, mid)
 350         sgPyQt.createTool(a, tid)
 351         a = sgPyQt.createAction( UI_ELT_IDS.OPEN_ADAOCASE_ID, "Open case", "Open case", "Open an adao case", "" )
 352         sgPyQt.createMenu(a, mid)
 353         sgPyQt.createTool(a, tid)
 354         a = sgPyQt.createAction( UI_ELT_IDS.SAVE_ADAOCASE_ID, "Save case", "Save case", "Save an adao case", "" )
 355         sgPyQt.createMenu(a, mid)
 356         sgPyQt.createTool(a, tid)
 357         a = sgPyQt.createAction( UI_ELT_IDS.SAVE_AS_ADAOCASE_ID, "Save as case", "Save as case", "Save an adao case as", "" )
 358         sgPyQt.createMenu(a, mid)
 359         sgPyQt.createTool(a, tid)
 360         a = sgPyQt.createAction( UI_ELT_IDS.CLOSE_ADAOCASE_ID, "Close case", "Close case", "Close an adao case", "" )
 361         sgPyQt.createMenu(a, mid)
 362         sgPyQt.createTool(a, tid)
 363
 364         # the following action are used in context popup
 365         a = sgPyQt.createAction( UI_ELT_IDS.CLOSE_ADAOCASE_ID, "Close case", "Close case", "Close the selected case", "" )
 366
 367         a = sgPyQt.createAction( UI_ELT_IDS.EDIT_ADAOCASE_POP_ID, "Edit case", "Edit case", "Edit the selected study case", "" )
 368         a = sgPyQt.createAction( UI_ELT_IDS.YACS_EXPORT_POP_ID, "Export to YACS", "Export to YACS", "Generate a YACS graph executing this case", "" )
 369
 370     def createPopupMenuOnItem(self,popup,salomeSudyId, item):
 371         if adaoStudyEditor.isValidAdaoCaseItem(salomeSudyId, item):
 372           popup.addAction( sgPyQt.action( UI_ELT_IDS.CLOSE_ADAOCASE_ID ) )
 373
 374           popup.addAction( sgPyQt.action( UI_ELT_IDS.EDIT_ADAOCASE_POP_ID ) )
 375           popup.addAction( sgPyQt.action( UI_ELT_IDS.YACS_EXPORT_POP_ID ) )
 376
 377         return popup
 378
 379 class AdaoGuiActionImpl(EficasObserver):
 380     """
 381     This class implements the ui actions concerning the management of oma study
 382     cases.
 383     """
 384
 385     def __init__(self):
 386         pass
 387         # This dialog is created once so that it can be recycled for each call
 388         # to newOmaCase().
 389         #self.__dlgNewStudyCase = DlgNewStudyCase()
 390         self.__parent = SalomePyQt.SalomePyQt().getDesktop()
 391         self.__dlgEficasWrapper = AdaoEficasWrapper(parent=SalomePyQt.SalomePyQt().getDesktop())
 392         self.__dlgEficasWrapper.addObserver(self)
 393         self.__Eficas_viewId = -1
 394
 395     # ==========================================================================
 396     # Processing of ui actions
 397     #
 398     def processAction(self,actionId):
 399         """
 400         Main switch function for ui actions processing
 401         """
 402         if ACTIONS_MAP.has_key(actionId):
 403             try:
 404                 functionName = ACTIONS_MAP[actionId]
 405                 getattr(self,functionName)()
 406             except:
 407                 traceback.print_exc()
 408         else:
 409             msg = "The requested action is not implemented: " + str(actionId)
 410             print msg
 411
 412     def showEficas(self):
 413       if self.__Eficas_viewId == -1:
 414         self.__dlgEficasWrapper.init_gui()
 415
 416
 417         # Scroll Widget
 418         area = QtGui.QScrollArea(SalomePyQt.SalomePyQt().getDesktop());
 419         area.setWidget( self.__dlgEficasWrapper)
 420         area.setWidgetResizable(1)
 421
 422         wmType = "ADAO View"
 423         self.__Eficas_viewId = sgPyQt.createView(wmType, area)
 424         sgPyQt.setViewClosable(self.__Eficas_viewId, False)
 425       else:
 426         if SalomePyQt.SalomePyQt().getActiveView() != self.__Eficas_viewId :
 427           result_activate = SalomePyQt.SalomePyQt().activateView(self.__Eficas_viewId)
 428           if result_activate == False:
 429             self.__dlgEficasWrapper.init_gui()
 430
 431             # Scroll Widget
 432             area = QtGui.QScrollArea(SalomePyQt.SalomePyQt().getDesktop());
 433             area.setWidget( self.__dlgEficasWrapper)
 434             area.setWidgetResizable(1)
 435
 436             wmType = "ADAO View"
 437             self.__Eficas_viewId = sgPyQt.createView(wmType, area)
 438             sgPyQt.setViewClosable(self.__Eficas_viewId, False)
 439         self.__dlgEficasWrapper.setEnabled(True)
 440
 441     def activate(self):
 442       self.showEficas()
 443
 444     def deactivate(self):
 445       self.showEficas()
 446       if self.__Eficas_viewId != -1:
 447         self.__dlgEficasWrapper.setEnabled(False)
 448
 449     # Actions from SALOME GUI
 450
 451     def newAdaoCase(self):
 452
 453       adaoLogger.debug("newAdaoCase")
 454       self.showEficas()
 455       self.__dlgEficasWrapper.fileNew()
 456
 457     def openAdaoCase(self):
 458
 459       adaoLogger.debug("openAdaoCase")
 460       self.showEficas()
 461       global __cases__
 462       fichier = QtGui.QFileDialog.getOpenFileName(SalomePyQt.SalomePyQt().getDesktop(),
 463                                                   self.__dlgEficasWrapper.trUtf8('Ouvrir Fichier'),
 464                                                   self.__dlgEficasWrapper.CONFIGURATION.savedir,
 465                                                   self.__dlgEficasWrapper.trUtf8('JDC Files (*.comm);;''All Files (*)'))
 466       if fichier.isNull(): return
 467       new_case = AdaoCase()
 468       new_case.set_filename(str(fichier))
 469       new_case.set_name(str(fichier.split('/')[-1]))
 470       salomeStudyId   = adaoGuiHelper.getActiveStudyId()
 471       salomeStudyItem = adaoStudyEditor.addInStudy(salomeStudyId, new_case)
 472       case_key = (salomeStudyId, salomeStudyItem.GetID())
 473       __cases__[case_key] = new_case
 474
 475       # Open file in Eficas
 476       self.__dlgEficasWrapper.Openfile(new_case.get_filename())
 477       callbackId = [salomeStudyId, salomeStudyItem]
 478       self.__dlgEficasWrapper.setCallbackId(callbackId)
 479       self.showEficas()
 480       adaoGuiHelper.refreshObjectBrowser()
 481
 482     def editAdaoCase(self):
 483
 484       adaoLogger.debug("editAdaoCase")
 485       global __cases__
 486
 487       # Take study item
 488       salomeStudyId   = adaoGuiHelper.getActiveStudyId()
 489       salomeStudyItem = adaoGuiHelper.getSelectedItem(salomeStudyId)
 490       case_key = (salomeStudyId, salomeStudyItem.GetID())
 491
 492       # ShowEficas, If case is an empty case - case is destroyed by reopen
 493       self.showEficas()
 494       try:
 495         case = __cases__[case_key]
 496         # Search if case is in Eficas !
 497         callbackId = [salomeStudyId, salomeStudyItem]
 498         case_open_in_eficas = self.__dlgEficasWrapper.selectCase(callbackId)
 499
 500         # If case is not in eficas Open It !
 501         if case_open_in_eficas == False:
 502           if case.get_filename() != "":
 503             self.__dlgEficasWrapper.Openfile(case.get_filename())
 504             callbackId = [salomeStudyId, salomeStudyItem]
 505             self.__dlgEficasWrapper.setCallbackId(callbackId)
 506       except:
 507         # Case has been destroyed - create a new one
 508         self.__dlgEficasWrapper.fileNew()
 509
 510     def closeAdaoCase(self):
 511
 512       adaoLogger.debug("closeAdaoCase")
 513       global __cases__
 514
 515       # First step: get selected case
 516       salomeStudyId   = adaoGuiHelper.getActiveStudyId()
 517       salomeStudyItem = adaoGuiHelper.getSelectedItem(salomeStudyId)
 518
 519       # Check if there is a selected case
 520       if salomeStudyItem is None:
 521         print "[Close case] Please select a case"
 522         return
 523
 524       callbackId = [salomeStudyId, salomeStudyItem]
 525       case_open_in_eficas = self.__dlgEficasWrapper.selectCase(callbackId)
 526
 527       # If case is in eficas close it !
 528       if case_open_in_eficas:
 529         # fileClose: remove the CallbackId
 530         # fileClose: sends a destroy event
 531         self.__dlgEficasWrapper.fileClose()
 532       else:
 533         # Test if case exists
 534         case_key = (salomeStudyId, salomeStudyItem.GetID())
 535         if __cases__.has_key(case_key):
 536           __cases__.pop(case_key)
 537           adaoStudyEditor.removeItem(salomeStudyId, salomeStudyItem)
 538           adaoGuiHelper.refreshObjectBrowser()
 539
 540     def saveAdaoCase(self):
 541
 542       adaoLogger.debug("saveAdaoCase")
 543       global __cases__
 544
 545     def saveasAdaoCase(self):
 546
 547       adaoLogger.debug("saveasAdaoCase")
 548       global __cases__
 549
 550     def exportCaseToYACS(self):
 551
 552       adaoLogger.debug("exportCaseToYACS")
 553       global __cases__
 554
 555       # Get case from study
 556       salomeStudyId   = adaoGuiHelper.getActiveStudyId()
 557       salomeStudyItem = adaoGuiHelper.getSelectedItem(salomeStudyId)
 558       case_key = (salomeStudyId, salomeStudyItem.GetID())
 559       case = __cases__[case_key]
 560
 561       # Generates YACS schema and export it
 562       msg = case.exportCaseToYACS()
 563
 564       # If msg is not empty -> error found
 565       if msg != "":
 566         adaoGuiHelper.gui_warning(self.__parent, msg)
 567
 568     # ==========================================================================
 569     # Processing notifications from adaoEficasWrapper
 570     #
 571     __processOptions={
 572         EficasEvent.EVENT_TYPES.CLOSE   : "_processEficasCloseEvent",
 573         EficasEvent.EVENT_TYPES.SAVE    : "_processEficasSaveEvent",
 574         EficasEvent.EVENT_TYPES.NEW     : "_processEficasNewEvent",
 575         EficasEvent.EVENT_TYPES.OPEN    : "_processEficasOpenEvent",
 576         EficasEvent.EVENT_TYPES.REOPEN  : "_processEficasReOpenEvent"
 577         }
 578     def processEficasEvent(self, eficasWrapper, eficasEvent):
 579         """
 580         Implementation of the interface EficasObserver. The implementation is a
 581         switch on the possible types of events defined in EficasEvent.EVENT_TYPES.
 582         @overload
 583         """
 584         functionName = self.__processOptions.get(eficasEvent.eventType, lambda : "_processEficasUnknownEvent")
 585         return getattr(self,functionName)(eficasWrapper, eficasEvent)
 586
 587     def _processEficasCloseEvent(self, eficasWrapper, eficasEvent):
 588         pass
 589
 590     def _processEficasNewEvent(self, eficasWrapper, eficasEvent):
 591       global __cases__
 592
 593       new_case = AdaoCase()
 594       case_name = eficasWrapper.getCaseName()
 595       new_case.set_name(case_name)
 596       salomeStudyId   = adaoGuiHelper.getActiveStudyId()
 597       salomeStudyItem = adaoStudyEditor.addInStudy(salomeStudyId, new_case)
 598       case_key = (salomeStudyId, salomeStudyItem.GetID())
 599       __cases__[case_key] = new_case
 600       adaoGuiHelper.refreshObjectBrowser()
 601       callbackId = [salomeStudyId, salomeStudyItem]
 602       self.__dlgEficasWrapper.setCallbackId(callbackId)
 603
 604       # We need to select the case
 605       adaoGuiHelper.selectItem(salomeStudyItem.GetID())
 606
 607
 608     def _processEficasOpenEvent(self, eficasWrapper, eficasEvent):
 609       global __cases__
 610
 611       # Ouverture du fichier
 612       self.__dlgEficasWrapper.Openfile(self.__dlgEficasWrapper.getOpenFileName())
 613
 614       # Creation d'un nouveau cas
 615       new_case = AdaoCase()
 616       salomeStudyId   = adaoGuiHelper.getActiveStudyId()
 617       salomeStudyItem = adaoStudyEditor.addInStudy(salomeStudyId, new_case)
 618       case_key = (salomeStudyId, salomeStudyItem.GetID())
 619       __cases__[case_key] = new_case
 620
 621       # Connexion du nouveau cas
 622       callbackId = [salomeStudyId, salomeStudyItem]
 623       self.__dlgEficasWrapper.setCallbackId(callbackId)
 624
 625       # On sauvegarde le cas
 626       self._processEficasSaveEvent(self.__dlgEficasWrapper, None, callbackId)
 627
 628     def _processEficasSaveEvent(self, eficasWrapper, eficasEvent, callbackId=None):
 629         global __cases__
 630         if callbackId is None:
 631           callbackId = eficasEvent.callbackId
 632           if callbackId is None:
 633             raise DevelException("the callback data should not be None. Can't guess what are the study and case")
 634           [targetSalomeStudyId,targetSalomeStudyItem] = callbackId
 635           if ( targetSalomeStudyId is None ) or ( targetSalomeStudyItem is None ):
 636             raise DevelException("the parameters targetSalomeStudyId and targetSalomeStudyItem should not be None")
 637         else:
 638           [targetSalomeStudyId,targetSalomeStudyItem] = callbackId
 639
 640         # Get Editor All infos we need !
 641         case_name = eficasWrapper.getCaseName()
 642         file_case_name = eficasWrapper.getFileCaseName()
 643         if case_name != "" :
 644           # Get case
 645           old_case_key = (targetSalomeStudyId, targetSalomeStudyItem.GetID())
 646           case =__cases__[old_case_key]
 647
 648           # Set new informations
 649           case.set_name(case_name)
 650           if str(case_name).startswith("Untitled"):
 651             pass
 652           else:
 653             case.set_filename(file_case_name)
 654           adaoStudyEditor.updateItem(targetSalomeStudyId, targetSalomeStudyItem, case)
 655
 656           # Case key changed !
 657           #new_case_key = (targetSalomeStudyId, targetSalomeStudyItem.GetID())
 658           # A ne pas inverser !!!
 659           #__cases__.pop(old_case_key)
 660           #__cases__[new_case_key] = case
 661
 662           adaoGuiHelper.refreshObjectBrowser()
 663
 664     def _processEficasDestroyEvent(self, eficasWrapper, eficasEvent):
 665         global __cases__
 666         callbackId = eficasEvent.callbackId
 667         if callbackId is None:
 668             raise DevelException("the callback data should not be None. Can't guess what are the study and case")
 669         [targetSalomeStudyId,targetSalomeStudyItem] = callbackId
 670         if ( targetSalomeStudyId is None ) or ( targetSalomeStudyItem is None ):
 671             raise DevelException("the parameters targetSalomeStudyId and targetSalomeStudyItem should not be None")
 672
 673         case_key = (targetSalomeStudyId, targetSalomeStudyItem.GetID())
 674         __cases__.pop(case_key)
 675         adaoStudyEditor.removeItem(targetSalomeStudyId, targetSalomeStudyItem)
 676         adaoGuiHelper.refreshObjectBrowser()
 677
 678     # Deprecated
 679     # Normalement on ne ferme plus le GUI donc on ne passe plus par là
 680     def _processEficasReOpenEvent(self, eficasWrapper, eficasEvent):
 681
 682       adaoLogger.warning("_processEficasReOpenEvent")
 683       global __cases__
 684
 685       try:
 686         callbackId = eficasEvent.callbackId
 687         [salomeStudyId, salomeStudyItem] = callbackId
 688         case_key = (salomeStudyId, salomeStudyItem.GetID())
 689         case = __cases__[case_key]
 690         # Search if case is in Eficas !
 691         callbackId = [salomeStudyId, salomeStudyItem]
 692         case_open_in_eficas = self.__dlgEficasWrapper.selectCase(callbackId)
 693         # If case is not in eficas Open It !
 694         if case_open_in_eficas == False:
 695           if case.get_filename() != "":
 696             self.__dlgEficasWrapper.Openfile(case.get_filename())
 697             callbackId = [salomeStudyId, salomeStudyItem]
 698             self.__dlgEficasWrapper.setCallbackId(callbackId)
 699           else:
 700             # Since I am an empty case I destroy myself before reloading
 701             adaoStudyEditor.removeItem(salomeStudyId, salomeStudyItem)
 702             adaoGuiHelper.refreshObjectBrowser()
 703             __cases__.pop(case_key)
 704             callbackId = [salomeStudyId, salomeStudyItem]
 705             self.__dlgEficasWrapper.removeCallbackId(callbackId)
 706       except:
 707         print "Oups - cannot reopen case !"
 708         traceback.print_exc()
 709
 710     def _processEficasUnknownEvent(self, eficasWrapper, eficasEvent):
 711       print "Unknown Eficas Event"