Inheritance diagram for Vispa.Main.TabController.TabController:

Public Member Functions
def	__init__ (self, plugin)

def	activated (self)

def	addUndoEvent (self, undoEvent)

def	allowClose (self)

def	allowSelectAll (self)

def	cancel (self)

def	checkModificationTimestamp (self)

def	close (self)

def	copy (self)

def	cut (self)

def	dumpUndoEvents (self)

def	enableUndo (self, enable=True)

def	filename (self)

def	find (self)

def	getFileBasename (self)

def	isCopyPasteEnabled (self)

def	isEditable (self)

def	isFindEnabled (self)

def	isModified (self)

def	open (self, filename=None, update=True)

def	paste (self)

def	plugin (self)

def	readFile (self, filename)

def	redo (self, numberOfEvents=1)

def	redoEvents (self)

def	refresh (self)

def	resetZoomButtonPressedBefore (self)

def	save (self, filename="")

def	selectAll (self)

def	setAllowSelectAll (self, allowSelectAll)

def	setCopyPasteEnabled (self, enable=True)

def	setEditable (self, editable)

def	setFilename (self, filename)

def	setFindEnabled (self, enable=True)

def	setLastSavedStateEvent (self, undoEvent)

def	setModified (self, modified=True)

def	setTab (self, tab)

def	setZoom (self, zoom)

def	staticSupportedFileTypes ()

def	supportedFileFilters (self)

def	supportedFileTypes (self)

def	supportsUndo (self)

def	tab (self)

def	undo (self, numberOfEvents=1)

def	undoEvents (self)

def	updateContent (self)

def	updateLabel (self, prefix="", titletext="")

def	writeFile (self, filename)

def	zoom (self)

def	zoomAll (self)

def	zoomChanged (self, zoom)

def	zoomDialog (self)

def	zoomHundred (self)

def	zoomUser (self)

Private Attributes
	_allowSelectAllFlag

	_copyPasteEnabledFlag

	_fileModifcationTimestamp

	_fileModifiedFlag

	_filename

	_findEnabledFlag

	_isEditableFlag

	_plugin

	_redoEvents

	_showingModifiedMessageFlag

	_supportsUndo

	_tab

	_undoEvents

	_userZoomLevel

	_zoomButtonPressedBeforeFlag

Detailed Description

Base class for all tab controllers.

Tab controllers control the functionality of plugin tabs.

Definition at line 12 of file TabController.py.

Constructor & Destructor Documentation

def Vispa.Main.TabController.TabController.__init__	(	self,
		plugin
	)

Definition at line 20 of file TabController.py.

     def __init__(self, plugin):
         QObject.__init__(self)
         logging.debug(__name__ + ": __init__")
         self._plugin = plugin
         self._fileModifiedFlag = False
         self._isEditableFlag = True
         self._tab = None
         self._filename = None
         self._copyPasteEnabledFlag = False
         self._allowSelectAllFlag = False
         self._findEnabledFlag = False
         self._userZoomLevel = 100
         self._zoomButtonPressedBeforeFlag = False
         self._fileModifcationTimestamp = None
         self._showingModifiedMessageFlag=False
         self._supportsUndo = False
         self._undoEvents = []
         self._redoEvents = []
            

Member Function Documentation

def Vispa.Main.TabController.TabController.activated ( self )

Called by application when tab is activated in tabWidget.

This function should be overwritten if special treatment on tab selection is required.

Definition at line 366 of file TabController.py.

     def activated(self):
         """ Called by application when tab is activated in tabWidget.
         
         This function should be overwritten if special treatment on tab selection is required.
         """
         pass
         

def Vispa.Main.TabController.TabController.addUndoEvent	(	self,
		undoEvent
	)

Adds event of type UndoEvent to this tab controller's list of undoable events.

Undo can be invoked by calling undo().

Definition at line 543 of file TabController.py.

References Vispa.Main.TabController.TabController._redoEvents, Vispa.Main.TabController.TabController._supportsUndo, Vispa.Main.TabController.TabController._undoEvents, Vispa.Main.TabController.TabController.isModified(), PFTauMVAInputDiscriminantTranslator::DiscriminantInfo.plugin, Vispa.Main.TabController.TabController.plugin(), Vispa.Main.Application.Application.plugin(), and Vispa.Main.TabController.TabController.setLastSavedStateEvent().

     def addUndoEvent(self, undoEvent):
         """ Adds event of type UndoEvent to this tab controller's list of undoable events.
         
         Undo can be invoked by calling undo().
         """
         if self._supportsUndo:
             if not isinstance(undoEvent, UndoEvent):
                 logging.error("%s: Tried to add non-UndoEvent to list of undo events. Aborting..." % self.__class__.__name__)
                 return
             self._redoEvents = []
             no_of_events = len(self._undoEvents)
             # try to combine similar events
             if no_of_events < 1 or not self._undoEvents[no_of_events -1].combine(undoEvent):
                 self._undoEvents.append(undoEvent)
                 if not self.isModified():
                     self.setLastSavedStateEvent(undoEvent)
                 self.plugin().application().updateMenu()
         else:
             logging.warning("%s: Tried to add undo event, however undo functionality is not enabled. Aborting..." % self.__class__.__name__)    
         #self.dumpUndoEvents()
         

def Vispa.Main.TabController.TabController.allowClose ( self )

Definition at line 272 of file TabController.py.

References Vispa.Main.TabController.TabController.isEditable(), Vispa.Main.TabController.TabController.isModified(), PFTauMVAInputDiscriminantTranslator::DiscriminantInfo.plugin, Vispa.Main.TabController.TabController.plugin(), Vispa.Main.Application.Application.plugin(), CalibrationHistograms.save(), l1t::WriterProxy.save(), TkHistoMap.save(), l1t::WriterProxyT< Record, Type >.save(), NuclearInteractionSimulator.save(), PiecewiseScalingPolynomial.save(), HcalIndexLookup.save(), HBHENegativeEFilter.save(), MaterialEffects.save(), HBHEChannelGroups.save(), MaterialEffectsSimulator.save(), fastsim::NuclearInteraction.save(), TrackerMap.save(), CommissioningHistograms.save(), OOTPileupCorrData.save(), SpecificationBuilder_cfi.Specification.save(), Vispa.Main.TabController.TabController.save(), svgfig.SVG.save(), DQMStore.save(), and TkAlMap.TkAlMap.save().

Referenced by Vispa.Main.TabController.TabController.close().

     def allowClose(self):
         if self.isEditable() and self.isModified():
             messageResult = self.plugin().application().showMessageBox("The document has been modified.",
                                                                        "Do you want to save your changes?",
                                                                        QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel,
                                                                        QMessageBox.Save)
             
             if messageResult == QMessageBox.Save:
                 if not self.save():
                     return False
             elif messageResult == QMessageBox.Cancel:
                 return False
         return True
     

def Vispa.Main.TabController.TabController.allowSelectAll ( self )

Evaluates the sllowSelectAll flag.

Definition at line 189 of file TabController.py.

References Vispa.Main.TabController.TabController._allowSelectAllFlag.

     def allowSelectAll(self):
         """ Evaluates the sllowSelectAll flag.
         """
         return self._allowSelectAllFlag
         

def Vispa.Main.TabController.TabController.cancel ( self )

Cancel all operations in tab.

This function is called when all current operations in tab shall be canceled.

Definition at line 513 of file TabController.py.

     def cancel(self):
         """ Cancel all operations in tab.
         
         This function is called when all current operations in tab shall be canceled.
         """
         pass
 

def Vispa.Main.TabController.TabController.checkModificationTimestamp ( self )

Compares the actual modification timestamp of self.filename() to the modification at opening or last save operation.

This function is called by Application when the tab associated with this controller was activated.
If modification timestamps differ the refresh() method is called.

Definition at line 313 of file TabController.py.

References Vispa.Main.TabController.TabController._fileModifcationTimestamp, Vispa.Main.TabController.TabController._filename, DQMIO2histo.DQMIO._filename, MuonGeometryArrange._filename, TrackerGeometryCompare._filename, Vispa.Main.TabController.TabController._showingModifiedMessageFlag, Vispa.Main.TabController.TabController.isEditable(), MELaserPrim.refresh(), Vispa.Main.TabController.TabController.refresh(), CalibrationHistograms.save(), l1t::WriterProxy.save(), TkHistoMap.save(), l1t::WriterProxyT< Record, Type >.save(), NuclearInteractionSimulator.save(), PiecewiseScalingPolynomial.save(), HcalIndexLookup.save(), HBHENegativeEFilter.save(), MaterialEffects.save(), HBHEChannelGroups.save(), MaterialEffectsSimulator.save(), fastsim::NuclearInteraction.save(), TrackerMap.save(), CommissioningHistograms.save(), OOTPileupCorrData.save(), SpecificationBuilder_cfi.Specification.save(), Vispa.Main.TabController.TabController.save(), svgfig.SVG.save(), DQMStore.save(), TkAlMap.TkAlMap.save(), and Vispa.Main.TabController.TabController.setModified().

     def checkModificationTimestamp(self):
         """ Compares the actual modification timestamp of self.filename() to the modification at opening or last save operation.
         
         This function is called by Application when the tab associated with this controller was activated.
         If modification timestamps differ the refresh() method is called.
         """
         if not self._filename or self._fileModifcationTimestamp == 0:
             return
         
         msgBox = None
         if not os.path.exists(self._filename):
             logging.debug(self.__class__.__name__ + ": checkModificationTimestamp() - File was removed.")
             self._fileModifcationTimestamp = 0
             msgBox = QMessageBox()
             msgBox.setText("The file was removed.")
             if self.isEditable():
                 msgBox.setInformativeText("Do you want to save the file with your version?")
                 saveButton = msgBox.addButton("Save", QMessageBox.ActionRole)
                 ignoreButton = msgBox.addButton("Ignore", QMessageBox.RejectRole)
             else:
                 ignoreButton = msgBox.addButton("OK", QMessageBox.RejectRole)
             reloadButton = None
             
         elif self._fileModifcationTimestamp != os.path.getmtime(self._filename):
             logging.debug(self.__class__.__name__ + ": checkModificationTimestamp() - File was modified.")
             msgBox = QMessageBox()
             msgBox.setText("The file has been modified.")
             if self.isEditable():
                 msgBox.setInformativeText("Do you want to overwrite the file with your version or reload the file?")
                 saveButton = msgBox.addButton("Overwrite", QMessageBox.ActionRole)
             else:
                 msgBox.setInformativeText("Do you want to reload the file?")
             reloadButton = msgBox.addButton("Reload", QMessageBox.DestructiveRole)
             ignoreButton = msgBox.addButton("Ignore", QMessageBox.RejectRole)
         
         if msgBox and not self._showingModifiedMessageFlag:
             self.setModified()
             self._showingModifiedMessageFlag=True
             msgBox.exec_()
             self._showingModifiedMessageFlag=False
             
             if self.isEditable() and msgBox.clickedButton() == saveButton:
                 self.save()
             elif msgBox.clickedButton() == reloadButton:            
                 self.refresh()
                 self.setModified(False)
             elif msgBox.clickedButton() == ignoreButton and os.path.exists(self._filename):
                 self._fileModifcationTimestamp = os.path.getmtime(self._filename)
                 
         else:
             #logging.debug(self.__class__.__name__ + ": checkModificationTimestamp() - File was not modified.")
             pass
     

def Vispa.Main.TabController.TabController.close ( self )

Asks user if he wants to save potentially unsaved data and closes the tab. 

This function usually does not need to be overwritten by a PluginTab.

Definition at line 286 of file TabController.py.

References Vispa.Main.TabController.TabController.allowClose(), and Vispa.Main.TabController.TabController.tab().

Referenced by lumiQTWidget.ApplicationWindow.fileQuit(), esMonitoring.AsyncLineReaderMixin.handle_close(), esMonitoring.FDJsonServer.handle_close(), Vispa.Gui.BoxContentDialog.BoxContentDialog.keyPressEvent(), and Vispa.Gui.FindDialog.FindDialog.keyPressEvent().

     def close(self):
         """ Asks user if he wants to save potentially unsaved data and closes the tab. 
         
         This function usually does not need to be overwritten by a PluginTab.
         """ 
         allowClose = self.allowClose()
         if allowClose:
             if self.tab().tabWidget():
                 self.tab().tabWidget().removeTab(self.tab().tabWidget().indexOf(self.tab()))
             #if self.tab() in self.tab().mainWindow()._tabWindows:
             #    self.tab().mainWindow()._tabWindows.remove(self.tab())
             self.tab().close()
             # no effect?
             #self._tab.deleteLater()
             #self._tab = None
         return allowClose
         

def Vispa.Main.TabController.TabController.copy ( self )

Handle copy event.

This function is called if the user selects 'Copy' from menu. PluginTabs should override it if needed.
See also setCopyPasteEnabled(), isCopyPasteEnabled().

Definition at line 381 of file TabController.py.

     def copy(self):
         """ Handle copy event.
         
         This function is called if the user selects 'Copy' from menu. PluginTabs should override it if needed.
         See also setCopyPasteEnabled(), isCopyPasteEnabled().
         """
         raise NotImplementedError
         

def Vispa.Main.TabController.TabController.cut ( self )

Handle cut event.

This function is called if the user selects 'Cut' from menu. PluginTabs should override it if needed.
See also setCopyPasteEnabled(), isCopyPasteEnabled().

Definition at line 373 of file TabController.py.

     def cut(self):
         """ Handle cut event.
         
         This function is called if the user selects 'Cut' from menu. PluginTabs should override it if needed.
         See also setCopyPasteEnabled(), isCopyPasteEnabled().
         """
         raise NotImplementedError
         

def Vispa.Main.TabController.TabController.dumpUndoEvents ( self )

Definition at line 632 of file TabController.py.

References Vispa.Main.TabController.TabController._redoEvents, and Vispa.Main.TabController.TabController._undoEvents.

     def dumpUndoEvents(self):
         for event in self._undoEvents:
             event.dump("undo")
         for event in self._redoEvents:
             event.dump("redo")

def Vispa.Main.TabController.TabController.enableUndo	(	self,
		enable = `True`
	)

If enable is True this controller enables its undo function.

For any tab controller that wants to use this feature, it needs to be made sure the corresponding UndoEvents
for actions that should be undoable exists and are added by addUndoEvent().

Definition at line 525 of file TabController.py.

References Vispa.Main.TabController.TabController._supportsUndo.

     def enableUndo(self, enable=True):
         """ If enable is True this controller enables its undo function.
         
         For any tab controller that wants to use this feature, it needs to be made sure the corresponding UndoEvents
         for actions that should be undoable exists and are added by addUndoEvent().
         """
         self._supportsUndo = enable
             

def Vispa.Main.TabController.TabController.filename ( self )

Returns filename of this tab.

Definition at line 80 of file TabController.py.

References Vispa.Main.TabController.TabController._filename, DQMIO2histo.DQMIO._filename, MuonGeometryArrange._filename, and TrackerGeometryCompare._filename.

Referenced by Vispa.Plugins.ConfigEditor.ConfigDataAccessor.ConfigDataAccessor.properties().

     def filename(self):
         """ Returns filename of this tab.
         """
         return self._filename
     

def Vispa.Main.TabController.TabController.find ( self )

Handle find event.

This function is called if the user selects 'Find' from menu. PluginTabs should override it if needed."
See also setFindEnabled(), isFindEnabled().

Definition at line 397 of file TabController.py.

     def find(self):
         """ Handle find event.
         
         This function is called if the user selects 'Find' from menu. PluginTabs should override it if needed."
         See also setFindEnabled(), isFindEnabled().
         """
         raise NotImplementedError
     

def Vispa.Main.TabController.TabController.getFileBasename ( self )

Returns the basename of this tab's filename.

Part of filename after last /.

Definition at line 85 of file TabController.py.

References Vispa.Main.TabController.TabController._filename, DQMIO2histo.DQMIO._filename, MuonGeometryArrange._filename, and TrackerGeometryCompare._filename.

     def getFileBasename(self):
         """ Returns the basename of this tab's filename.
         
         Part of filename after last /.
         """
         return os.path.basename(self._filename) 
     

def Vispa.Main.TabController.TabController.isCopyPasteEnabled ( self )

Return True if the copyPasteFlag is set.

See setCopyPasteEnabled(), cut(), copy(), paste().

Definition at line 99 of file TabController.py.

References Vispa.Main.TabController.TabController._copyPasteEnabledFlag.

     def isCopyPasteEnabled(self):
         """ Return True if the copyPasteFlag is set.
         
         See setCopyPasteEnabled(), cut(), copy(), paste().
         """
         return self._copyPasteEnabledFlag
     

def Vispa.Main.TabController.TabController.isEditable ( self )

Evaluates the file Editable flag.

Definition at line 178 of file TabController.py.

References Vispa.Main.TabController.TabController._isEditableFlag.

Referenced by Vispa.Plugins.EventBrowser.EventBrowserTabController.EventBrowserTabController.activated(), Vispa.Main.TabController.TabController.allowClose(), Vispa.Main.TabController.TabController.checkModificationTimestamp(), Vispa.Main.TabController.TabController.setModified(), and Vispa.Plugins.Browser.BrowserTabController.BrowserTabController.switchCenterView().

     def isEditable(self):
         """ Evaluates the file Editable flag.
         """
         return self._isEditableFlag
     

def Vispa.Main.TabController.TabController.isFindEnabled ( self )

Returns True if findEnabledFlag is set.

See setFindEnabled(), find().

Definition at line 113 of file TabController.py.

References Vispa.Main.TabController.TabController._findEnabledFlag.

     def isFindEnabled(self):
         """Returns True if findEnabledFlag is set.
         
         See setFindEnabled(), find().
         """
         return self._findEnabledFlag
     

def Vispa.Main.TabController.TabController.isModified ( self )

Evaluates the file Modified flag. Always returns True if no filename is set.

Definition at line 166 of file TabController.py.

References Vispa.Main.TabController.TabController._fileModifiedFlag.

Referenced by Vispa.Main.TabController.TabController.addUndoEvent(), Vispa.Main.TabController.TabController.allowClose(), and Vispa.Main.TabController.TabController.updateLabel().

     def isModified(self):
         """ Evaluates the file Modified flag. Always returns True if no filename is set.
         """
         return self._fileModifiedFlag
         

def Vispa.Main.TabController.TabController.open	(	self,
		filename = `None`,
		update = `True`
	)

Open given file.

Definition at line 194 of file TabController.py.

References Vispa.Main.TabController.TabController._filename, DQMIO2histo.DQMIO._filename, MuonGeometryArrange._filename, TrackerGeometryCompare._filename, PFTauMVAInputDiscriminantTranslator::DiscriminantInfo.plugin, Vispa.Main.TabController.TabController.plugin(), Vispa.Main.Application.Application.plugin(), SurveyDataReader.readFile(), SurveyInputTextReader.readFile(), DeviationsFromFileSensor2D.readFile(), CovarianceParameterization.readFile(), edm::InputSource.readFile(), edm::EventProcessor.readFile(), Vispa.Main.TabController.TabController.readFile(), DQMStore.readFile(), Vispa.Main.TabController.TabController.setFilename(), Vispa.Main.TabController.TabController.updateContent(), and Vispa.Main.TabController.TabController.updateLabel().

Referenced by Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController.importConfig().

     def open(self, filename=None, update=True):
         """ Open given file.
         """
         logging.debug(self.__class__.__name__ + ": open()")
         
         statusMessage = self.plugin().application().startWorking("Opening file " + filename)
             
         if filename == None:
             if self._filename:
                 filename = self._filename
             else:
                 self.plugin().application().stopWorking(statusMessage, "failed")
                 return False
         
         if self.readFile(filename):
             self.setFilename(filename)
             self.updateLabel()
             if update:
                 self.updateContent()
             self.plugin().application().stopWorking(statusMessage)
             return True
         
         self.plugin().application().stopWorking(statusMessage, "failed")
         return False
     

def Vispa.Main.TabController.TabController.paste ( self )

Handle paste event.

This function is called if the user selects 'Paste' from menu. PluginTabs should override it if needed."
See also setCopyPasteEnabled(), isCopyPasteEnabled().

Definition at line 389 of file TabController.py.

     def paste(self):
         """ Handle paste event.
         
         This function is called if the user selects 'Paste' from menu. PluginTabs should override it if needed."
         See also setCopyPasteEnabled(), isCopyPasteEnabled().
         """
         raise NotImplementedError
         

def Vispa.Main.TabController.TabController.plugin ( self )

Returns the plugin reference, set by setPlugin().

Definition at line 58 of file TabController.py.

References Vispa.Main.TabController.TabController._plugin.

     def plugin(self):
         """ Returns the plugin reference, set by setPlugin().
         """
         return self._plugin
        

def Vispa.Main.TabController.TabController.readFile	(	self,
		filename
	)

This function performs the actual reading of a file. It should be overwritten by any PluginTab which inherits Tab.
If the reading was successful True should be returned.
The file should be read from the file given in the argument filename not to the one in self._filename.

Definition at line 219 of file TabController.py.

Referenced by Vispa.Plugins.EventBrowser.EventBrowserTabController.EventBrowserTabController.navigate(), Vispa.Main.TabController.TabController.open(), and Vispa.Main.TabController.TabController.refresh().

     def readFile(self, filename):
         """
         This function performs the actual reading of a file. It should be overwritten by any PluginTab which inherits Tab.
         If the reading was successful True should be returned.
         The file should be read from the file given in the argument filename not to the one in self._filename.
         """
         raise NotImplementedError
     

def Vispa.Main.TabController.TabController.redo	(	self,
		numberOfEvents = `1`
	)

Definition at line 589 of file TabController.py.

References Vispa.Main.TabController.TabController._redoEvents, Vispa.Main.TabController.TabController._supportsUndo, Vispa.Main.TabController.TabController._undoEvents, PFTauMVAInputDiscriminantTranslator::DiscriminantInfo.plugin, Vispa.Main.TabController.TabController.plugin(), Vispa.Main.Application.Application.plugin(), Vispa.Main.TabController.TabController.setModified(), and str.

     def redo(self, numberOfEvents=1):
         if not self._supportsUndo:
             logging.warning(self.__class__.__name__ + ": Tried to undo action, however undo functionality is not enabled. Aborting...")
             return
         logging.debug(self.__class__.__name__ +": redo("+ str(numberOfEvents) +")")
         #self.dumpUndoEvents()
         
         for i in range(0, numberOfEvents):
             if len(self._redoEvents) > 0:
                 lastEvent = self._redoEvents.pop()
                 lastEvent.redo()
                 self._undoEvents.append(lastEvent)
                 
                 # set modification flag
                 if i == (numberOfEvents -1):
                     undo_events_count = len(self._redoEvents)
                     if undo_events_count > 0:
                         if self._redoEvents[undo_events_count-1].isLastSavedState():
                             self.setModified(False)
                         else:
                             self.setModified()
                     else:
                         # if there are no more redo events
                         # and there is no event with last saved state flag set to True
                         # no action was performed since the last save
                         # and thus modification flag should be False
                         modified = False
                         for event in self._undoEvents + self._redoEvents:
                             if event.isLastSavedState():
                                 modified = True
                                 break
                         self.setModified(modified)
                 self.plugin().application().updateMenu()
         

def Vispa.Main.TabController.TabController.redoEvents ( self )

Returns list of all UndoEvents that have already been undone before.

Definition at line 538 of file TabController.py.

References Vispa.Main.TabController.TabController._redoEvents.

     def redoEvents(self):
         """ Returns list of all UndoEvents that have already been undone before.
         """
         return self._redoEvents
             

def Vispa.Main.TabController.TabController.refresh ( self )

Reloads file content and refreshes tab.

May be implemented by inheriting controllers.

Definition at line 491 of file TabController.py.

References Vispa.Main.TabController.TabController._fileModifcationTimestamp, Vispa.Main.TabController.TabController._filename, DQMIO2histo.DQMIO._filename, MuonGeometryArrange._filename, TrackerGeometryCompare._filename, PFTauMVAInputDiscriminantTranslator::DiscriminantInfo.plugin, Vispa.Main.TabController.TabController.plugin(), Vispa.Main.Application.Application.plugin(), SurveyDataReader.readFile(), SurveyInputTextReader.readFile(), DeviationsFromFileSensor2D.readFile(), CovarianceParameterization.readFile(), edm::InputSource.readFile(), edm::EventProcessor.readFile(), Vispa.Main.TabController.TabController.readFile(), DQMStore.readFile(), and Vispa.Main.TabController.TabController.updateContent().

Referenced by Vispa.Main.TabController.TabController.checkModificationTimestamp().

     def refresh(self):
         """ Reloads file content and refreshes tab.
         
         May be implemented by inheriting controllers.
         """
         statusMessage = self.plugin().application().startWorking("Reopening file")
         self._fileModifcationTimestamp = os.path.getmtime(self._filename)
         self.readFile(self._filename)
         self.updateContent()
         self.plugin().application().stopWorking(statusMessage)
 

def Vispa.Main.TabController.TabController.resetZoomButtonPressedBefore ( self )

Sets the zoom button pressed before flag to False.

If the flag is set functions handling the zoom toolbar buttons (zoomHundred(), zoomAll()) wont store the last zoom factor. The flag is set to true by these functions.
By this mechanism the user can click the zoom buttons several times and will still be able to return to his orignal zoom level by zoomUser().
The reset function needs to be called if the user manually sets the zoom level. For instance by connecting this function to the wheelEvent of the workspace scroll area.

Definition at line 434 of file TabController.py.

References Vispa.Main.TabController.TabController._zoomButtonPressedBeforeFlag.

     def resetZoomButtonPressedBefore(self):
         """ Sets the zoom button pressed before flag to False.
         
         If the flag is set functions handling the zoom toolbar buttons (zoomHundred(), zoomAll()) wont store the last zoom factor. The flag is set to true by these functions.
         By this mechanism the user can click the zoom buttons several times and will still be able to return to his orignal zoom level by zoomUser().
         The reset function needs to be called if the user manually sets the zoom level. For instance by connecting this function to the wheelEvent of the workspace scroll area.
         """
         self._zoomButtonPressedBeforeFlag = False
         

def Vispa.Main.TabController.TabController.save	(	self,
		filename = `""`
	)

Takes care the tab's data will be written to the file given as argument or if this is an empty string to self._filename.

Whenever the content of the tab should be saved, this method should be called. If no filename is specified nor already set set it asks the user to set one. 
Afterwards the writing is initiated by calling writeFile().

Definition at line 227 of file TabController.py.

Referenced by Vispa.Main.TabController.TabController.allowClose(), and Vispa.Main.TabController.TabController.checkModificationTimestamp().

     def save(self, filename=""):
         """ Takes care the tab's data will be written to the file given as argument or if this is an empty string to self._filename.
         
         Whenever the content of the tab should be saved, this method should be called. If no filename is specified nor already set set it asks the user to set one. 
         Afterwards the writing is initiated by calling writeFile(). 
         """
         #logging.debug('Tab: save()')
         
         if filename == '':
             if self._filename:
                 filename = self._filename
             else:
                 return self.plugin().application().saveFileAsDialog()
         
         statusMessage = self.plugin().application().startWorking("Saving file " + filename)
 
         good=True
         message=""
         try:  
             good=self.writeFile(filename)
         except Exception as e:
             good=False
             message="\n"+str(e)
         if good:
             self.setFilename(filename)
             self.setModified(False)
             self.updateLabel()
             self.plugin().application().addRecentFile(filename)
             self.plugin().application().updateMenuAndWindowTitle()
             
             # set last saved state for undo events
             if len(self._redoEvents) > 0:
                 lastSavedStateEvent = self._redoEvents[len(self._redoEvents) -1]
             else:
                 lastSavedStateEvent = None
             self.setLastSavedStateEvent(lastSavedStateEvent)
             
             self.plugin().application().stopWorking(statusMessage)
             return True
         else:
             QMessageBox.critical(self.tab().mainWindow(), 'Error while saving data', 'Could not write to file ' + filename +'.'+message)
             logging.error(self.__class__.__name__ + ": save() : Could not write to file " + filename +'.'+message)
             self.plugin().application().stopWorking(statusMessage, "failed")
             return False
 

def Vispa.Main.TabController.TabController.selectAll ( self )

Handle to perform select all action.

This function is called if the user selects 'Select all' from menu. PluginTabs should override it if needed."
See also setAllowSelectAll(), allowSelectAll().

Definition at line 405 of file TabController.py.

     def selectAll(self):
         """ Handle to perform select all action.
         
         This function is called if the user selects 'Select all' from menu. PluginTabs should override it if needed."
         See also setAllowSelectAll(), allowSelectAll().
         """
         raise NotImplementedError
     

def Vispa.Main.TabController.TabController.setAllowSelectAll	(	self,
		allowSelectAll
	)

Sets the allowSelectAll flag.

Definition at line 183 of file TabController.py.

References Vispa.Main.TabController.TabController._allowSelectAllFlag, PFTauMVAInputDiscriminantTranslator::DiscriminantInfo.plugin, Vispa.Main.TabController.TabController.plugin(), and Vispa.Main.Application.Application.plugin().

     def setAllowSelectAll(self, allowSelectAll):
         """ Sets the allowSelectAll flag.
         """
         self._allowSelectAllFlag = allowSelectAll
         self.plugin().application().updateMenu()
         

def Vispa.Main.TabController.TabController.setCopyPasteEnabled	(	self,
		enable = `True`
	)

Sets a flag indicating whether this tab can handle copy and paste events.

See also isCopyPasteEnabled(), cut(), copy(), paste().

Definition at line 92 of file TabController.py.

References Vispa.Main.TabController.TabController._copyPasteEnabledFlag.

     def setCopyPasteEnabled(self, enable=True):
         """ Sets a flag indicating whether this tab can handle copy and paste events.
         
         See also isCopyPasteEnabled(), cut(), copy(), paste().
         """
         self._copyPasteEnabledFlag = enable
         

def Vispa.Main.TabController.TabController.setEditable	(	self,
		editable
	)

Sets the file Editable flag.

Definition at line 171 of file TabController.py.

References Vispa.Main.TabController.TabController._isEditableFlag, PFTauMVAInputDiscriminantTranslator::DiscriminantInfo.plugin, Vispa.Main.TabController.TabController.plugin(), and Vispa.Main.Application.Application.plugin().

Referenced by Vispa.Plugins.EventBrowser.EventBrowserTabController.EventBrowserTabController.__init__(), and Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController.startEditMode().

     def setEditable(self, editable):
         """ Sets the file Editable flag.
         """
         #logging.debug(self.__class__.__name__ +": setEditable(" + str(editable) +")")
         self._isEditableFlag = editable
         self.plugin().application().updateMenu()
         

def Vispa.Main.TabController.TabController.setFilename	(	self,
		filename
	)

Sets a filename.

Definition at line 73 of file TabController.py.

References Vispa.Main.TabController.TabController._fileModifcationTimestamp, Vispa.Main.TabController.TabController._filename, DQMIO2histo.DQMIO._filename, MuonGeometryArrange._filename, and TrackerGeometryCompare._filename.

Referenced by Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController.importConfig(), Vispa.Main.TabController.TabController.open(), Vispa.Main.TabController.TabController.save(), and Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController.startEditMode().

     def setFilename(self, filename):
         """ Sets a filename.
         """
         self._filename = filename
         if self._filename and os.path.exists(self._filename):
             self._fileModifcationTimestamp = os.path.getmtime(self._filename)
     

def Vispa.Main.TabController.TabController.setFindEnabled	(	self,
		enable = `True`
	)

Sets a flag indicating whether this tab can handle find requests.

See isFindEnabled(), find().

Definition at line 106 of file TabController.py.

References Vispa.Main.TabController.TabController._findEnabledFlag.

     def setFindEnabled(self, enable=True):
         """Sets a flag indicating whether this tab can handle find requests.
         
         See isFindEnabled(), find().
         """
         self._findEnabledFlag = enable
         

def Vispa.Main.TabController.TabController.setLastSavedStateEvent	(	self,
		undoEvent
	)

Sets last saved state flag of given UndoEvent to True and to False for all other events.

Definition at line 623 of file TabController.py.

References Vispa.Main.TabController.TabController._redoEvents, and Vispa.Main.TabController.TabController._undoEvents.

Referenced by Vispa.Main.TabController.TabController.addUndoEvent(), and Vispa.Main.TabController.TabController.save().

     def setLastSavedStateEvent(self, undoEvent):
         """ Sets last saved state flag of given UndoEvent to True and to False for all other events.
         """
         for current_event in self._undoEvents + self._redoEvents:
             if current_event == undoEvent:
                 current_event.setLastSavedState(True)
             else:
                 current_event.setLastSavedState(False)
 

def Vispa.Main.TabController.TabController.setModified	(	self,
		modified = `True`
	)

Sets the file Modified flag to True or False.

This affects the closing of this tab.
It is only possible to set the modification flag to True if the controller is editable (see isEditable()).

Definition at line 147 of file TabController.py.

References Vispa.Main.TabController.TabController._fileModifiedFlag, Vispa.Main.TabController.TabController.isEditable(), PFTauMVAInputDiscriminantTranslator::DiscriminantInfo.plugin, Vispa.Main.TabController.TabController.plugin(), Vispa.Main.Application.Application.plugin(), Vispa.Main.TabController.TabController.tab(), and Vispa.Main.TabController.TabController.updateLabel().

Referenced by Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController.applyButtonClicked(), Vispa.Main.TabController.TabController.checkModificationTimestamp(), Vispa.Main.TabController.TabController.redo(), Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController.removeButtonClicked(), Vispa.Main.TabController.TabController.save(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController.switchCenterView(), Vispa.Main.TabController.TabController.undo(), and Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController.valueChanged().

     def setModified(self, modified=True):
         """ Sets the file Modified flag to True or False.
         
         This affects the closing of this tab.
         It is only possible to set the modification flag to True if the controller is editable (see isEditable()).
         """
         if modified and not self.isEditable():
             return
 
         previous = self._fileModifiedFlag
         self._fileModifiedFlag = modified
         
         if previous != self._fileModifiedFlag:
             self.updateLabel()
             if self.tab().mainWindow():
                 self.plugin().application().updateMenuAndWindowTitle()
             else:
                 logging.info(self.__class__.__name__ +": setModified() - Cannot tell application the modification state: There is no application associated with the tab.")
         

def Vispa.Main.TabController.TabController.setTab	(	self,
		tab
	)

Sets tab.

Definition at line 63 of file TabController.py.

References Vispa.Main.TabController.TabController._tab.

     def setTab(self, tab):
         """ Sets tab.
         """
         self._tab = tab
         

def Vispa.Main.TabController.TabController.setZoom	(	self,
		zoom
	)

This function has to be implemented by tab controllers who want to use the zoom toolbar.

The implementation has to forward the zoom value to the Zoomable object for which the toolbar is set up.
See also zoom()

Definition at line 413 of file TabController.py.

Referenced by Vispa.Main.TabController.TabController.zoomAll(), Vispa.Main.TabController.TabController.zoomDialog(), Vispa.Main.TabController.TabController.zoomHundred(), and Vispa.Main.TabController.TabController.zoomUser().

     def setZoom(self, zoom):
         """ This function has to be implemented by tab controllers who want to use the zoom toolbar.
         
         The implementation has to forward the zoom value to the Zoomable object for which the toolbar is set up.
         See also zoom()
         """
         raise NotImplementedError
     

def Vispa.Main.TabController.TabController.staticSupportedFileTypes ( )

Static function returning all filetypes the tab controller can handle.

Sub classes should reimplement this function. It returns a list with 2-tuples of the following form:
('extension', 'description of file type').

Definition at line 40 of file TabController.py.

     def staticSupportedFileTypes():
         """ Static function returning all filetypes the tab controller can handle.
         
         Sub classes should reimplement this function. It returns a list with 2-tuples of the following form:
         ('extension', 'description of file type').
         """
         return []

def Vispa.Main.TabController.TabController.supportedFileFilters ( self )

Definition at line 54 of file TabController.py.

References join().

     def supportedFileFilters(self):
         supportedFileTypes = self.__class__.staticSupportedFileTypes()
         return ";;".join([Filetype(t[0], t[1]).fileDialogFilter() for t in supportedFileTypes])
             

def Vispa.Main.TabController.TabController.supportedFileTypes ( self )

Returns staticSupportedFileTypes() of the class to which this object belongs.

Definition at line 49 of file TabController.py.

     def supportedFileTypes(self):
         """ Returns staticSupportedFileTypes() of the class to which this object belongs.
         """
         return self.__class__.staticSupportedFileTypes()
     

def Vispa.Main.TabController.TabController.supportsUndo ( self )

Returns True if the this tab controller supports undo history.

Definition at line 520 of file TabController.py.

     def supportsUndo(self):
         """ Returns True if the this tab controller supports undo history.
         """
         return self._supportsUndo
     

def Vispa.Main.TabController.TabController.tab ( self )

Returns tab.

Definition at line 68 of file TabController.py.

References Vispa.Main.TabController.TabController._tab.

     def tab(self):
         """ Returns tab.
         """
         return self._tab
     

def Vispa.Main.TabController.TabController.undo	(	self,
		numberOfEvents = `1`
	)

Invokes undo of last stored UndoEvent (see addUndoEvent()), if undo functionality is enabled.

Definition at line 564 of file TabController.py.

References Vispa.Main.TabController.TabController._supportsUndo, Vispa.Main.TabController.TabController._undoEvents, PFTauMVAInputDiscriminantTranslator::DiscriminantInfo.plugin, Vispa.Main.TabController.TabController.plugin(), Vispa.Main.Application.Application.plugin(), Vispa.Main.TabController.TabController.setModified(), and str.

     def undo(self, numberOfEvents=1):
         """ Invokes undo of last stored UndoEvent (see addUndoEvent()), if undo functionality is enabled.
         """
         if not self._supportsUndo:
             logging.warning(self.__class__.__name__ + ": Tried to undo action, however undo functionality is not enabled. Aborting...")
             return
         logging.debug(self.__class__.__name__ +": undo("+ str(numberOfEvents) +")")
         #self.dumpUndoEvents()
         
         for i in range(0, numberOfEvents):
             if len(self._undoEvents) > 0:
                 lastEvent = self._undoEvents.pop()
                 lastEvent.undo()
                 self._redoEvents.append(lastEvent)
                 
                 # set modification flag
                 if i == (numberOfEvents -1):
                     if lastEvent.isLastSavedState():
                         self.setModified(False)
                     else:
                         self.setModified()
                 self.plugin().application().updateMenu()
                 
         #self.dumpUndoEvents()
         

def Vispa.Main.TabController.TabController.undoEvents ( self )

Returns list of all registered UndoEvents.

Definition at line 533 of file TabController.py.

References Vispa.Main.TabController.TabController._undoEvents.

     def undoEvents(self):
         """ Returns list of all registered UndoEvents.
         """
         return self._undoEvents
     

def Vispa.Main.TabController.TabController.updateContent ( self )

Called after file is loaded.

Meant to update to Tab content.

Definition at line 484 of file TabController.py.

Referenced by Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController._updateCode(), Vispa.Plugins.Browser.BrowserTabController.BrowserTabController.filtered(), Vispa.Plugins.EventBrowser.EventBrowserTabController.EventBrowserTabController.navigate(), Vispa.Main.TabController.TabController.open(), Vispa.Main.TabController.TabController.refresh(), Vispa.Plugins.EdmBrowser.EventContentDialog.EventContentDialog.selectInputFile(), Vispa.Plugins.EdmBrowser.EventContentDialog.EventContentDialog.setConfigDataAccessor(), Vispa.Plugins.EdmBrowser.EventContentDialog.EventContentDialog.setEventContent(), and Vispa.Plugins.EdmBrowser.EdmBrowserTabController.EdmBrowserTabController.toggleFilterBranches().

     def updateContent(self):
         """ Called after file is loaded.
         
         Meant to update to Tab content.
         """
         raise NotImplementedError
 

def Vispa.Main.TabController.TabController.updateLabel	(	self,
		prefix = `""`,
		titletext = `""`
	)

Sets the text of the tab to filename if it is set. If
titletext
is not an emty string, it is used instead of the filename.

Otherwise it is set to 'UNTITLED'. It also evaluates the fileModifiedFlag and indicates changes with an *.

Definition at line 120 of file TabController.py.

References Vispa.Main.TabController.TabController._filename, DQMIO2histo.DQMIO._filename, MuonGeometryArrange._filename, TrackerGeometryCompare._filename, Vispa.Main.TabController.TabController.isModified(), digitizers_cfi.strip, and Vispa.Main.TabController.TabController.tab().

Referenced by Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController.importConfig(), Vispa.Main.TabController.TabController.open(), Vispa.Main.TabController.TabController.save(), Vispa.Main.TabController.TabController.setModified(), and Vispa.Plugins.ConfigEditor.ConfigEditorTabController.ConfigEditorTabController.startEditMode().

     def updateLabel(self,prefix="",titletext = ""):
         """ Sets the text of the tab to filename if it is set. If
         titletext
         is not an emty string, it is used instead of the filename.
         
         Otherwise it is set to 'UNTITLED'. It also evaluates the fileModifiedFlag and indicates changes with an *.
         """
         if self._filename:
             title = os.path.basename(self._filename)
             if len(os.path.splitext(title)[0]) > self.TAB_LABEL_MAX_LENGTH:
                 ext = os.path.splitext(title)[1].lower().strip(".")
                 title = os.path.splitext(title)[0][0:self.TAB_LABEL_MAX_LENGTH] + "...." + ext
         elif titletext == "":
             title = 'UNTITLED'
         else:
             title = titletext
         
         if self.isModified():
             title = '*' + title
         
         title = prefix+title
         
         if self.tab().tabWidget():
             self.tab().tabWidget().setTabText(self.tab().tabWidget().indexOf(self.tab()), title)
         else:
             self.tab().setWindowTitle(title)
         

def Vispa.Main.TabController.TabController.writeFile	(	self,
		filename
	)

This function performs the actual writing / saving of a file. It should be overwritten by any PluginTab which inherits Tab.
If the writing was successful True should be returned.
The file should be written to the file given in the argument filename not to the one in self._filename.
These variables may differ in case the user selects "save as..." and picks a new filename on a file which already has a name set.
If writing was successful the self._filename variable will then be set to the value of filename.

Definition at line 303 of file TabController.py.

Referenced by Vispa.Main.TabController.TabController.save().

     def writeFile(self, filename):
         """
         This function performs the actual writing / saving of a file. It should be overwritten by any PluginTab which inherits Tab.
         If the writing was successful True should be returned.
         The file should be written to the file given in the argument filename not to the one in self._filename.
         These variables may differ in case the user selects "save as..." and picks a new filename on a file which already has a name set.
         If writing was successful the self._filename variable will then be set to the value of filename.
         """
         raise NotImplementedError
     

def Vispa.Main.TabController.TabController.zoom ( self )

This function has to be implemented by tab controllers who want to use the zoom toolbar.

The implementation should return the zoom value of the Zoomable object for which the toolbar is set up.
See also setZoom()

Definition at line 421 of file TabController.py.

Referenced by Vispa.Main.TabController.TabController.zoomAll(), Vispa.Main.TabController.TabController.zoomDialog(), and Vispa.Main.TabController.TabController.zoomHundred().

     def zoom(self):
         """ This function has to be implemented by tab controllers who want to use the zoom toolbar.
         
         The implementation should return the zoom value of the Zoomable object for which the toolbar is set up.
         See also setZoom()
         """
         raise NotImplementedError
           

def Vispa.Main.TabController.TabController.zoomAll ( self )

Zooms workspace content to fit optimal.

Currently only works if scroll area is used and accessible through self.tab().scrollArea().

Definition at line 458 of file TabController.py.

References Vispa.Main.TabController.TabController._userZoomLevel, Vispa.Main.TabController.TabController._zoomButtonPressedBeforeFlag, Vispa.Gui.Zoomable.Zoomable.setZoom(), Vispa.Gui.ZoomableScrollableWidgetOwner.ZoomableScrollableWidgetOwner.setZoom(), Vispa.Gui.ZoomableWidget.ZoomableWidget.setZoom(), Vispa.Gui.ZoomableScrollArea.ZoomableScrollArea.setZoom(), Vispa.Gui.PortConnection.PointToPointConnection.setZoom(), Vispa.Gui.ConnectableWidget.ConnectableWidget.setZoom(), Vispa.Main.TabController.TabController.setZoom(), Vispa.Gui.VispaWidget.VispaWidget.setZoom(), Vispa.Main.TabController.TabController.tab(), ApeEstimator_cff.width, Vispa.Gui.Zoomable.Zoomable.zoom(), and Vispa.Main.TabController.TabController.zoom().

     def zoomAll(self):
         """ Zooms workspace content to fit optimal.
         
         Currently only works if scroll area is used and accessible through self.tab().scrollArea().
         """
         logging.debug(__name__ + ": zoomAll()")
         if not self._zoomButtonPressedBeforeFlag:
             self._userZoomLevel = self.zoom()
             self._zoomButtonPressedBeforeFlag = True
             
         viewportWidth = self.tab().scrollArea().viewport().width() 
         viewportHeight = self.tab().scrollArea().viewport().height()
         
         for i in range(0, 2):
             # do 2 iterations to prevent rounding error --> better fit
             workspaceChildrenRect = self.tab().scrollArea().widget().childrenRect()
             widthRatio = self.zoom() * viewportWidth / (workspaceChildrenRect.right())
             heightRatio = self.zoom() * viewportHeight / (workspaceChildrenRect.bottom())
         
             if widthRatio > heightRatio:
                 ratio = heightRatio
             else:
                 ratio = widthRatio
         
             self.setZoom(math.floor(ratio))
     

def Vispa.Main.TabController.TabController.zoomChanged	(	self,
		zoom
	)

Shows zoom value on main window's status bar.

Definition at line 429 of file TabController.py.

References str, and Vispa.Main.TabController.TabController.tab().

     def zoomChanged(self, zoom):
         """ Shows zoom value on main window's status bar.
         """
         self.tab().mainWindow().statusBar().showMessage("Zoom " + str(round(zoom)) + " %")
     

def Vispa.Main.TabController.TabController.zoomDialog ( self )

Definition at line 502 of file TabController.py.

References Vispa.Main.TabController.TabController._userZoomLevel, Vispa.Gui.Zoomable.Zoomable.setZoom(), Vispa.Gui.ZoomableScrollableWidgetOwner.ZoomableScrollableWidgetOwner.setZoom(), Vispa.Gui.ZoomableWidget.ZoomableWidget.setZoom(), Vispa.Gui.ZoomableScrollArea.ZoomableScrollArea.setZoom(), Vispa.Gui.PortConnection.PointToPointConnection.setZoom(), Vispa.Gui.ConnectableWidget.ConnectableWidget.setZoom(), Vispa.Main.TabController.TabController.setZoom(), Vispa.Gui.VispaWidget.VispaWidget.setZoom(), Vispa.Main.TabController.TabController.tab(), Vispa.Gui.Zoomable.Zoomable.zoom(), and Vispa.Main.TabController.TabController.zoom().

     def zoomDialog(self):
         if hasattr(QInputDialog, "getInteger"):
             # Qt 4.3
             (zoom, ok) = QInputDialog.getInteger(self.tab(), "Zoom...", "Input zoom factor in percent:", self.zoom(), 0)
         else:
             # Qt 4.5
             (zoom, ok) = QInputDialog.getInt(self.tab(), "Zoom...", "Input zoom factor in percent:", self.zoom(), 0)
         if ok:
             self.setZoom(zoom)
             self._userZoomLevel = zoom
 

def Vispa.Main.TabController.TabController.zoomHundred ( self )

Sets zoom factor to 100 %.

Definition at line 449 of file TabController.py.

References Vispa.Main.TabController.TabController._userZoomLevel, Vispa.Main.TabController.TabController._zoomButtonPressedBeforeFlag, Vispa.Gui.Zoomable.Zoomable.setZoom(), Vispa.Gui.ZoomableScrollableWidgetOwner.ZoomableScrollableWidgetOwner.setZoom(), Vispa.Gui.ZoomableWidget.ZoomableWidget.setZoom(), Vispa.Gui.ZoomableScrollArea.ZoomableScrollArea.setZoom(), Vispa.Gui.PortConnection.PointToPointConnection.setZoom(), Vispa.Gui.ConnectableWidget.ConnectableWidget.setZoom(), Vispa.Main.TabController.TabController.setZoom(), Vispa.Gui.VispaWidget.VispaWidget.setZoom(), Vispa.Gui.Zoomable.Zoomable.zoom(), and Vispa.Main.TabController.TabController.zoom().

     def zoomHundred(self):
         """ Sets zoom factor to 100 %.
         """
         logging.debug(__name__ + ": zoomHundred()")
         if not self._zoomButtonPressedBeforeFlag:
             self._userZoomLevel = self.zoom()
             self._zoomButtonPressedBeforeFlag = True
         self.setZoom(100)
     

def Vispa.Main.TabController.TabController.zoomUser ( self )

Returns to the manually set zoom factor before zoomHundred() or zoomAll() were called.

Definition at line 443 of file TabController.py.

References Vispa.Main.TabController.TabController._userZoomLevel, Vispa.Gui.Zoomable.Zoomable.setZoom(), Vispa.Gui.ZoomableScrollableWidgetOwner.ZoomableScrollableWidgetOwner.setZoom(), Vispa.Gui.ZoomableWidget.ZoomableWidget.setZoom(), Vispa.Gui.ZoomableScrollArea.ZoomableScrollArea.setZoom(), Vispa.Gui.PortConnection.PointToPointConnection.setZoom(), Vispa.Gui.ConnectableWidget.ConnectableWidget.setZoom(), Vispa.Main.TabController.TabController.setZoom(), and Vispa.Gui.VispaWidget.VispaWidget.setZoom().

     def zoomUser(self):
         """ Returns to the manually set zoom factor before zoomHundred() or zoomAll() were called.
         """
         logging.debug(__name__ + ": zoomUser()")
         self.setZoom(self._userZoomLevel)
     