InterfaceQT4/viewManager.py

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