InterfaceQT4/viewManagerSsIhm.py

   1 # -*- coding: utf-8 -*-
   2 # Copyright (C) 2007-2021   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 from __future__ import absolute_import
  22 try :
  23    from builtins import str
  24    from builtins import object
  25 except : pass
  26
  27 import os
  28 from Extensions.i18n import tr
  29 import six
  30 from  PyQt5.QtWidgets  import QFileDialog, QMessageBox
  31 from  PyQt5.QtCore     import QFileInfo
  32
  33 # --------------------------------
  34 class JdcSsIhmHandler(object):
  35 # --------------------------------
  36 # retourne a l utilisateur
  37
  38    def __init__(self,viewManager):
  39 #  --------------------------------------
  40        self.viewManagerSsIhm=viewManager
  41
  42    def viewJdcPy(self) :
  43 #  ---------------------
  44        self.viewManagerSsIhm.handleViewJdcPy(self)
  45
  46    def viewJdcSource(self) :
  47 #  ---------------------
  48        self.viewManagerSsIhm.handleViewJdcSource(self)
  49
  50    def getFileName(self):
  51 #  ---------------------
  52        self.viewManagerSsIhm.getFileName(self)
  53
  54    def viewJdcRapport(self) :
  55 #  ---------------------
  56        self.viewManagerSsIhm.handleViewJdcRapport(self)
  57
  58    def getJdcRapport(self) :
  59 #  ---------------------
  60        return self.viewManagerSsIhm.handleGetJdcRapport(self)
  61
  62    def getDicoPython(self) :
  63 #  -------------------------
  64        return self.viewManagerSsIhm.generDico(self)
  65
  66    def isJdcValid(self) :
  67 #  -------------------------
  68        return self.viewManagerSsIhm.isJdcValid(self)
  69
  70    def fileSaveAs(self,fileName):
  71 #  -------------------------
  72        return self.viewManagerSsIhm.fileSaveAs(self,fileName)
  73
  74    def fileLegerSaveAs(self,fileName):
  75 #  -----------------------------------
  76        return self.viewManagerSsIhm.fileLegerSaveAs(self,fileName)
  77
  78
  79
  80 #--------------------------------
  81 class MyViewManagerSsIhm(object):
  82 #--------------------------------
  83 # Symetrique de ViewManager mais pas d heritage entre les 2
  84 # dans le viewManager pas de souci pour savoir qui est le jdc sur lequel on travaille
  85 # ici en revanche.... c est moins sur
  86
  87 #  --------------------------------
  88    def __init__(self,appliEficas):
  89 #  --------------------------------
  90        self.appliEficas=appliEficas
  91        self.tabWidgets = []
  92        self.mesIndexes = {}
  93        self.dictEditors={}
  94        self.untitledCount = 0
  95        self.doubles = {}
  96
  97 #  ------------------------------------------------------
  98    def handleOpen(self,fichier=None, units=None):
  99 #  ------------------------------------------------------
 100        result = None
 101        if fichier is None:
 102              print ('nom de fichier obligatoire')
 103              return None
 104
 105        for handler in self.dictEditors :
 106            editor=self.dictEditors[handler]
 107            if self.samePath(fichier, editor.getFileName()):
 108               print ('fichier deja ouvert . pas de nouvel editor')
 109               return handler
 110
 111        monNewHandler = self.getNewEditor(fichier,units)
 112        return monNewHandler
 113
 114 #  ----------------------------------------------------------------------
 115    def getNewEditor(self,fichier = None,jdc = None, units = None,include=0):
 116 #  ----------------------------------------------------------------------
 117
 118        from InterfaceQT4.editorSsIhm import JDCEditorSsIhm
 119        editor = JDCEditorSsIhm(self.appliEficas,fichier,jdc, units=units,include=include)
 120
 121        if editor.jdc: # le fichier est bien un jdc
 122           monHandler = JdcSsIhmHandler(self)
 123           self.dictEditors[monHandler]=editor
 124           return monHandler
 125        else:
 126           print ('impossible de construire le jdc')
 127           return None
 128
 129 #  -----------------------------
 130    def samePath(self,f1, f2):
 131 #  ------------------------------
 132     """
 133     compare two paths.
 134     """
 135     if f1 is None or f2 is None: return 0
 136     if os.path.normcase(os.path.normpath(f1)) == os.path.normcase(os.path.normpath(f2)) : return 1
 137     return 0
 138
 139 #  ---------------------------------
 140    def handleViewJdcPy(self,handler):
 141 #  ---------------------------------
 142         if not (handler in self.dictEditors) :
 143            print ('editor non trouve')
 144            return
 145         self.dictEditors[handler].viewJdcPy()
 146
 147 #  ---------------------------------
 148    def getFileName(self,handler):
 149 #  ---------------------------------
 150         if not (handler in self.dictEditors) :
 151            print ('editor non trouve')
 152            return
 153         return self.dictEditors[handler].getFileName()
 154
 155
 156 #  ---------------------------------------------
 157    def handleViewJdcSource(self,handler):
 158 #  ---------------------------------------------
 159         print (handler)
 160         if not (handler in self.dictEditors) :
 161            print ('editor non trouve')
 162            return
 163         self.dictEditors[handler].viewJdcSource()
 164
 165
 166 #  ---------------------------------------------
 167    def handleViewJdcRapport(self,handler):
 168 #  ---------------------------------------------
 169         print (handler)
 170         if not (handler in self.dictEditors) :
 171            print ('editor non trouve')
 172            return
 173         self.dictEditors[handler].viewJdcRapport()
 174
 175 #  ---------------------------------------------
 176    def handleGetJdcRapport(self,handler):
 177 #  ---------------------------------------------
 178         if not (handler in self.dictEditors) :
 179            print ('editor non trouve')
 180            return
 181         return self.dictEditors[handler].getJdcRapport()
 182
 183 #  ---------------------------------------------
 184    def handleViewJdcRapport(self,handler):
 185 #  ---------------------------------------------
 186         print (handler)
 187         if not (handler in self.dictEditors) :
 188            print ('editor non trouve')
 189            return
 190         self.dictEditors[handler].viewJdcRapport()
 191
 192
 193 #  ---------------------------------------------
 194    def generDico(self,handler):
 195 #  ---------------------------------------------
 196         print (handler)
 197         if not (handler in self.dictEditors) :
 198            print ('editor non trouve')
 199            return
 200         return self.dictEditors[handler].generDico()
 201
 202
 203 #  ---------------------------------------------
 204    def isJdcValid(self,handler):
 205 #  ---------------------------------------------
 206         print (handler)
 207         if not (handler in self.dictEditors) :
 208            print ('editor non trouve')
 209            return
 210         return self.dictEditors[handler].jdc.isValid()
 211
 212
 213 #  ---------------------------------------------
 214    def fileSaveAs(self,handler,fileName):
 215 #  ---------------------------------------------
 216         print (handler)
 217         if not (handler in self.dictEditors) :
 218            print ('editor non trouve')
 219            return
 220         return self.dictEditors[handler].saveFile(fileName)
 221
 222 #  ---------------------------------------------
 223    def fileLegerSaveAs(self, handler,fileName):
 224 #  ---------------------------------------------
 225 #        print (handler)
 226         if not (handler in self.dictEditors) :
 227            print ('editor non trouve')
 228            return
 229         self.dictEditors[handler].saveFileLegerAs(fileName)
 230
 231
 232 #   def handleClose(self,doitSauverRecent = 1,texte=tr('&Quitter')):
 233 #       if doitSauverRecent : self.appliEficas.sauveRecents()
 234 #       index=self.myQtab.currentIndex()
 235 #       if index < 0 : return
 236 #       res=self.checkDirty(self.dict_editors[index],texte)
 237 #       if res == 2 : return 2             # l utilisateur a annule
 238 #       index=self.myQtab.currentIndex()
 239 #       idx=index
 240 #       while idx < len(self.dict_editors) -1 :
 241 #             self.dict_editors[idx]=self.dict_editors[idx+1]
 242 #             idx = idx + 1
 243 #       del self.dict_editors[len (self.dict_editors) -1]
 244 #       try :
 245 #           del self.doubles[self.dict_editors[index]]
 246 #       except :
 247 #           pass
 248 #       self.myQtab.removeTab(index)
 249 #       return res
 250 #
 251
 252 #
 253 #   def handleCloseAll(self,texte=tr('Quitter')):
 254 #       res=0
 255 #       self.appliEficas.sauveRecents()
 256 #       while len(self.dict_editors) > 0 :
 257 #             self.myQtab.setCurrentIndex(0)
 258 #             res=self.handleClose(0,texte)
 259 #             if res==2 : return res   # l utilsateur a annule
 260 #       return res
 261 #
 262 #
 263 #
 264 #   def newEditor(self,include=0):
 265 #       if self.appliEficas.demande==True :
 266 #           self.appliEficas.definitCode(None,None)
 267 #           if self.appliEficas.code == None:return
 268 #       maPage=self.getEditor(include=include)
 269 #
 270
 271 #
 272 #   def handleViewJdcRegles(self):
 273 #       index=self.myQtab.currentIndex()
 274 #       if index < 0 : return
 275 #       self.dict_editors[index].viewJdcRegles()
 276 #
 277 #   def handleGestionParam(self):
 278 #       index=self.myQtab.currentIndex()
 279 #       if index < 0 :
 280 #          QMessageBox.warning( self.appliEficas,tr(u"Creation Parametre indisponible"),tr(u"les parametres sont lies a un jeu de donnees"))
 281 #          return
 282 #       self.dict_editors[index].gestionParam()
 283 #
 284 #
 285 #
 286 #   def saveCurrentEditor(self):
 287 #       index=self.myQtab.currentIndex()
 288 #       if index < 0 : return
 289 #       editor=self.dict_editors[index]
 290 #       if editor in self.doubles :
 291 #           QMessageBox.warning(
 292 #                     None,
 293 #                     tr("Fichier Duplique"),
 294 #                     tr("Le fichier ne sera pas sauvegarde."),)
 295 #           return
 296 #       ok, newName = editor.saveFile()
 297 #       if ok :
 298 #           fileName=os.path.basename(six.text_type(newName))
 299 #           self.myQtab.setTabText(index,fileName)
 300 #       return ok
 301 #
 302 #   def saveLegerCurrentEditor(self):
 303 #       index=self.myQtab.currentIndex()
 304 #       if index < 0 : return
 305 #       editor=self.dict_editors[index]
 306 #       ok, newName = editor.saveFileLeger()
 307 #       return ok
 308 #
 309 #   def sauveLigneCurrentEditor(self):
 310 #       index=self.myQtab.currentIndex()
 311 #       if index < 0 : return
 312 #       editor=self.dict_editors[index]
 313 #       if editor in self.doubles :
 314 #           QMessageBox.warning(
 315 #                     None,
 316 #                     tr("Fichier Duplique"),
 317 #                     tr("Le fichier ne sera pas sauvegarde."),)
 318 #           return
 319 #       ok, newName = editor.sauveLigneFile()
 320 #       if ok :
 321 #           fileName=os.path.basename(six.text_type(newName))
 322 #           self.myQtab.setTabText(index,fileName)
 323 #       return ok
 324 #
 325 #
 326 #   def saveAsCurrentEditor(self):
 327 #       index=self.myQtab.currentIndex()
 328 #       editor=self.dict_editors[index]
 329 #       oldName=editor.fichier
 330 #       ok,newName = editor.saveFileAs()
 331 #       if ok :
 332 #           fileName=os.path.basename(six.text_type(newName))
 333 #           self.myQtab.setTabText(index,fileName)
 334 #       if editor in self.doubles :
 335 #          if oldName != newName :
 336 #             del self.doubles[editor]
 337 #       return ok
 338 #
 339 #   def displayJDC(self,jdc,fn=None):
 340 #        """
 341 #        Public slot to display a file in an editor.
 342 #        @param fn name of file to be opened
 343 #        # insert filename into list of recently opened files
 344 #        """
 345 #        titre=None
 346 #        if fn != None : titre=fn.split("/")[-1]
 347 #        editor = self.getEditor(fichier= fn, jdc = jdc ,include=1)
 348 #        self.appliEficas.addToRecentList(editor.getFileName())
 349 #
 350
 351 ##PNPNPNPN --> a affiner
 352 #        if fichier is None:
 353 #            self.untitledCount += 1
 354 #            self.myQtab.addTab(win, tr("Fichier non encore nomme ", self.untitledCount))
 355 #            #self.myQtab.addTab(win, str(self.appliEficas.code))
 356 #        else:
 357 #            liste=fichier.split('/')
 358 #            txt =  liste[-1]
 359 #            if not QFileInfo(fichier).isWritable():
 360 #                txt = '%s (ro)' % txt
 361 #            self.myQtab.addTab(win,txt )
 362 #        self.myQtab.setCurrentWidget(win)
 363 #        self.currentEditor=win
 364 #        win.setFocus()
 365 #
 366 #   def getOpenStartDir(self) :
 367 #       #PN --> Les Preferences
 368 #        try :
 369 #            userDir=os.path.expanduser("~/Eficas_install/")
 370 #            return userDir
 371 #        except :
 372 #            return ""
 373 #
 374 #
 375 #   def checkDirty(self, editor,texte):
 376 #        """
 377 #        Private method to check dirty status and open a message window.
 378 #
 379 #        @param editor editor window to check
 380 #        @return flag indicating successful reset of the dirty flag (boolean)
 381 #        """
 382 #        res=1
 383 #        if (editor.modified) and (editor in self.doubles) :
 384 #            msgBox = QMessageBox(None)
 385 #            msgBox.setWindowTitle(tr("Fichier Duplique"))
 386 #            msgBox.setText(tr("Le fichier ne sera pas sauvegarde."))
 387 #            msgBox.addButton(texte,0)
 388 #            msgBox.addButton(tr("&Annuler"),1)
 389 #            res=msgBox.exec_()
 390 #            if res == 0 : return 1
 391 #            return 2
 392 #        if editor.modified:
 393 #            fn = editor.getFileName()
 394 #            if fn is None: fn = tr('Noname')
 395 #            msgBox = QMessageBox(None)
 396 #            msgBox.setWindowTitle(tr("Fichier Modifie"))
 397 #            msgBox.setText(tr("Le fichier ne sera pas sauvegarde."))
 398 #            msgBox.addButton(tr("&Sauvegarder"),1)
 399 #            msgBox.addButton(tr("&Quitter sans sauvegarder"),0)
 400 #            msgBox.addButton(tr("&Annuler"),2)
 401 #            res=msgBox.exec_()
 402 #            if res == 2 : return res
 403 #            if res == 0:
 404 #                (ok, newName) = editor.saveFile()
 405 #                if ok:
 406 #                    fileName=os.path.basename(six.text_type(newName))
 407 #                    index=self.myQtab.currentIndex()
 408 #                    self.myQtab.setTabText(index,fileName)
 409 #                return ok
 410 #        return res
 411 #
 412 #   def handleAjoutGroup(self,listeGroup):
 413 #       index=self.myQtab.currentIndex()
 414 #       if index < 0 : return
 415 #       editor=self.dict_editors[index]
 416 #       editor.handleAjoutGroup(listeGroup)