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