eric: comparison Plugins/ViewManagerPlugins/Tabview/Tabview.py

-:6e09a9a73cb7
+:8b49d3e0b4c8
 from ViewManager.ViewManager import ViewManager
 import QScintilla.Editor
 from QScintilla.Editor import Editor
+from QScintilla.EditorAssembly import EditorAssembly
 import UI.PixmapCache
 from E5Gui.E5TabWidget import E5TabWidget, E5WheelTabBar
 from E5Gui.E5Led import E5Led
 def __init__(self, parent=None):
 """
 Constructor
-@param parent reference to the parent widget (QWidget)
+@param parent reference to the parent widget
+@type QWidget
 """
 super(TabBar, self).__init__(parent)
 self.setAcceptDrops(True)
 self.__dragStartPos = QPoint()
 def mousePressEvent(self, event):
 """
 Protected method to handle mouse press events.
-@param event reference to the mouse press event (QMouseEvent)
+@param event reference to the mouse press event
+@type QMouseEvent
 """
 if event.button() == Qt.LeftButton:
 self.__dragStartPos = QPoint(event.pos())
 super(TabBar, self).mousePressEvent(event)
 def mouseMoveEvent(self, event):
 """
 Protected method to handle mouse move events.
-@param event reference to the mouse move event (QMouseEvent)
+@param event reference to the mouse move event
+@type QMouseEvent
 """
 if event.buttons() == Qt.MouseButtons(Qt.LeftButton) and \
 (event.pos() - self.__dragStartPos).manhattanLength() > \
 QApplication.startDragDistance():
 drag = QDrag(self)
 def dragEnterEvent(self, event):
 """
 Protected method to handle drag enter events.
-@param event reference to the drag enter event (QDragEnterEvent)
+@param event reference to the drag enter event
+@type QDragEnterEvent
 """
 mimeData = event.mimeData()
 formats = mimeData.formats()
 if "action" in formats and \
 mimeData.data("action") == b"tab-reordering" and \
 def dropEvent(self, event):
 """
 Protected method to handle drop events.
-@param event reference to the drop event (QDropEvent)
+@param event reference to the drop event
+@type QDropEvent
 """
 mimeData = event.mimeData()
 oldID = int(mimeData.data("tabbar-id"))
 fromIndex = int(mimeData.data("source-index"))
 toIndex = self.tabAt(event.pos())
 """
 def __init__(self, vm):
 """
 Constructor
-@param vm view manager widget (Tabview)
+@param vm view manager widget
+@type Tabview
 """
 super(TabWidget, self).__init__()
 self.__tabBar = TabBar(self)
 self.setTabBar(self.__tabBar)
 def __showContextMenu(self, coord, index):
 """
 Private slot to show the tab context menu.
-@param coord the position of the mouse pointer (QPoint)
+@param coord the position of the mouse pointer
-@param index index of the tab the menu is requested for (integer)
+@type QPoint
+@param index index of the tab the menu is requested for
+@type int
 """
 if self.editors:
 self.contextMenuEditor = self.widget(index).getEditor()
 if self.contextMenuEditor:
 self.saveMenuAct.setEnabled(
 def __navigationMenuTriggered(self, act):
 """
 Private slot called to handle the navigation button menu selection.
-@param act reference to the selected action (QAction)
+@param act reference to the selected action
+@type QAction
 """
 index = act.data()
 if index is not None:
 self.setCurrentIndex(index)
 def showIndicator(self, on):
 """
 Public slot to set the indicator on or off.
-@param on flag indicating the dtate of the indicator (boolean)
+@param on flag indicating the state of the indicator
+@type bool
 """
 if on:
 self.indicator.setColor(QColor("green"))
 else:
 self.indicator.setColor(QColor("red"))
 def addTab(self, assembly, title):
 """
 Public method to add a new tab.
 @param assembly editor assembly object to be added
-(QScintilla.EditorAssembly.EditorAssembly)
+@type QScintilla.EditorAssembly.EditorAssembly
-@param title title for the new tab (string)
+@param title title for the new tab
+@type str
 """
 editor = assembly.getEditor()
 super(TabWidget, self).addTab(
 assembly, UI.PixmapCache.getIcon("empty.png"), title)
 if self.closeButton:
 def insertWidget(self, index, assembly, title):
 """
 Public method to insert a new tab.
-@param index index position for the new tab (integer)
+@param index index position for the new tab
+@type int
 @param assembly editor assembly object to be added
-(QScintilla.EditorAssembly.EditorAssembly)
+@type QScintilla.EditorAssembly.EditorAssembly
-@param title title for the new tab (string)
+@param title title for the new tab
-@return index of the inserted tab (integer)
+@type str
+@return index of the inserted tab
+@rtype int
 """
 editor = assembly.getEditor()
 newIndex = super(TabWidget, self).insertTab(
 index, assembly,
 UI.PixmapCache.getIcon("empty.png"),
 Updates the tab text and tooltip text to reflect the new caption
 information.
 @param cap Caption for the editor
+@type str
 @param editor Editor to update the caption for
+@type Editor
 """
 fn = editor.getFileName()
 if fn:
 if Preferences.getUI("TabViewManagerFilenameOnly"):
 txt = os.path.basename(fn)
 def __cursorLineChanged(self, lineno):
 """
 Private slot to handle a change of the current editor's cursor line.
 @param lineno line number of the current editor's cursor (zero based)
+@type int
 """
 editor = self.sender()
 if editor and isinstance(editor, QScintilla.Editor.Editor):
 fn = editor.getFileName()
 if fn:
 def removeWidget(self, widget):
 """
 Public method to remove a widget.
-@param widget widget to be removed (QWidget)
+@param widget widget to be removed
+@type QWidget
 """
 if isinstance(widget, QScintilla.Editor.Editor):
 widget.cursorLineChanged.disconnect(self.__cursorLineChanged)
 widget.captionChanged.disconnect(self.__captionChange)
 self.editors.remove(widget)
 def __relocateTab(self, sourceId, sourceIndex, targetIndex):
 """
 Private method to relocate an editor from another TabWidget.
-@param sourceId id of the TabWidget to get the editor from (string)
+@param sourceId id of the TabWidget to get the editor from
-@param sourceIndex index of the tab in the old tab widget (integer)
+@type str
-@param targetIndex index position to place it to (integer)
+@param sourceIndex index of the tab in the old tab widget
+@type int
+@param targetIndex index position to place it to
+@type int
 """
 tw = self.vm.getTabWidgetById(int(sourceId))
 if tw is not None:
 # step 1: get data of the tab of the source
 toolTip = tw.tabToolTip(sourceIndex)
 def __copyTabOther(self, sourceId, sourceIndex, targetIndex):
 """
 Private method to copy an editor from another TabWidget.
-@param sourceId id of the TabWidget to get the editor from (string)
+@param sourceId id of the TabWidget to get the editor from
-@param sourceIndex index of the tab in the old tab widget (integer)
+@type str
-@param targetIndex index position to place it to (integer)
+@param sourceIndex index of the tab in the old tab widget
+@type int
+@param targetIndex index position to place it to
+@type int
 """
 tw = self.vm.getTabWidgetById(int(sourceId))
 if tw is not None:
 editor = tw.widget(sourceIndex).getEditor()
 newEditor, assembly = self.vm.cloneEditor(
 def __copyTab(self, sourceIndex, targetIndex):
 """
 Private method to copy an editor.
-@param sourceIndex index of the tab (integer)
+@param sourceIndex index of the tab
-@param targetIndex index position to place it to (integer)
+@type int
+@param targetIndex index position to place it to
+@type int
 """
 editor = self.widget(sourceIndex).getEditor()
 newEditor, assembly = self.vm.cloneEditor(
 editor, editor.getFileType(), editor.getFileName())
 self.vm.insertView(assembly, self, targetIndex,
 def currentWidget(self):
 """
 Public method to return a reference to the current page.
-@return reference to the current page (Editor)
+@return reference to the current page
+@rtype Editor
 """
 if not self.editors:
 return None
 else:
 return super(TabWidget, self).currentWidget()
 def setCurrentWidget(self, assembly):
 """
 Public method to set the current tab by the given editor assembly.
 @param assembly editor assembly to determine current tab from
-(EditorAssembly.EditorAssembly)
+@type EditorAssembly.EditorAssembly
 """
 super(TabWidget, self).setCurrentWidget(assembly)
 def indexOf(self, widget):
 """
 Public method to get the tab index of the given editor.
-@param widget widget to get the index for (QLabel or Editor)
+@param widget widget to get the index for
-@return tab index of the editor (integer)
+@type QLabel or Editor
+@return tab index of the editor
+@rtype int
 """
 if isinstance(widget, QScintilla.Editor.Editor):
 widget = widget.parent()
 return super(TabWidget, self).indexOf(widget)
 def hasEditor(self, editor):
 """
 Public method to check for an editor.
 @param editor editor object to check for
+@type Editor
 @return flag indicating, whether the editor to be checked belongs
 to the list of editors managed by this tab widget.
+@rtype bool
 """
 return editor in self.editors
 def hasEditors(self):
 """
 Public method to test, if any editor is managed.
 @return flag indicating editors are managed
+@rtype bool
 """
 return len(self.editors) > 0
 def __contextMenuClose(self):
 """
 def __init__(self, parent):
 """
 Constructor
-@param parent parent widget (QWidget)
+@param parent parent widget
+@type QWidget
 """
 self.tabWidgets = []
 self.__splitter = QSplitter(parent)
 ViewManager.__init__(self)
 def canCascade(self):
 """
 Public method to signal if cascading of managed windows is available.
 @return flag indicating cascading of windows is available
+@rtype bool
 """
 return False
 def canTile(self):
 """
 Public method to signal if tiling of managed windows is available.
 @return flag indicating tiling of windows is available
+@rtype bool
 """
 return False
 def canSplit(self):
 """
 public method to signal if splitting of the view is available.
 @return flag indicating splitting of the view is available.
+@rtype bool
 """
 return True
 def tile(self):
 """
 def _removeView(self, win):
 """
 Protected method to remove a view (i.e. window).
 @param win editor window to be removed
+@type Editor
 """
 self.__inRemoveView = True
 for tw in self.tabWidgets:
 if tw.hasEditor(win):
 tw.removeWidget(win)
 self.editorLineChanged.emit(fn, aw.getCursorPosition()[0] + 1)
 else:
 self.changeCaption.emit("")
 self.editorChangedEd.emit(aw)
-def _addView(self, win, fn=None, noName="", addNext=False):
+def _addView(self, win, fn=None, noName="", addNext=False, indexes=None):
 """
 Protected method to add a view (i.e. window).
 @param win editor assembly to be added
-@param fn filename of this editor (string)
+@type EditorAssembly
-@param noName name to be used for an unnamed editor (string)
+@param fn filename of this editor
+@type str
+@param noName name to be used for an unnamed editor
+@type str
 @param addNext flag indicating to add the view next to the current
-view (bool)
+view
+@type bool
+@param indexes of the editor, first the split view index, second the
+index within the view
+@type tuple of two int
 """
 editor = win.getEditor()
 if fn is None:
 if not noName:
 self.untitledCount += 1
 noName = self.tr("Untitled {0}").format(self.untitledCount)
 if addNext:
 index = self.currentTabWidget.currentIndex() + 1
 self.currentTabWidget.insertWidget(index, win, noName)
+elif indexes:
+if indexes[0] < len(self.tabWidgets):
+tw = self.tabWidgets[indexes[0]]
+else:
+tw = self.tabWidgets[-1]
+tw.insertWidget(indexes[1], win, noName)
 else:
 self.currentTabWidget.addTab(win, noName)
 editor.setNoName(noName)
 else:
 if self.filenameOnly:
 if not QFileInfo(fn).isWritable():
 txt = self.tr("{0} (ro)").format(txt)
 if addNext:
 index = self.currentTabWidget.currentIndex() + 1
 self.currentTabWidget.insertWidget(index, win, txt)
+elif indexes:
+if indexes[0] < len(self.tabWidgets):
+tw = self.tabWidgets[indexes[0]]
+else:
+tw = self.tabWidgets[-1]
+tw.insertWidget(indexes[1], win, txt)
 else:
 self.currentTabWidget.addTab(win, txt)
 index = self.currentTabWidget.indexOf(win)
 self.currentTabWidget.setTabToolTip(index, fn)
 self.currentTabWidget.setCurrentWidget(win)
 def insertView(self, win, tabWidget, index, fn=None, noName=""):
 """
 Public method to add a view (i.e. window).
 @param win editor assembly to be inserted
+@type EditorAssembly
 @param tabWidget reference to the tab widget to insert the editor into
-(TabWidget)
+@type TabWidget
-@param index index position to insert at (integer)
+@param index index position to insert at
-@param fn filename of this editor (string)
+@type int
-@param noName name to be used for an unnamed editor (string)
+@param fn filename of this editor
+@type str
+@param noName name to be used for an unnamed editor
+@type str
 """
 editor = win.getEditor()
 if fn is None:
 if not noName:
 self.untitledCount += 1
 def _showView(self, win, fn=None):
 """
 Protected method to show a view (i.e. window).
 @param win editor assembly to be shown
-@param fn filename of this editor (string)
+@type EditorAssembly
+@param fn filename of this editor
+@type str
 """
 win.show()
 editor = win.getEditor()
 for tw in self.tabWidgets:
 if tw.hasEditor(editor):
 def activeWindow(self):
 """
 Public method to return the active (i.e. current) window.
 @return reference to the active editor
+@rtype Editor
 """
 cw = self.currentTabWidget.currentWidget()
 if cw:
 return cw.getEditor()
 else:
 def showWindowMenu(self, windowMenu):
 """
 Public method to set up the viewmanager part of the Window menu.
 @param windowMenu reference to the window menu
+@type QMenu
 """
 pass
 def _initWindowActions(self):
 """
 def setEditorName(self, editor, newName):
 """
 Public method to change the displayed name of the editor.
 @param editor editor window to be changed
-@param newName new name to be shown (string)
+@type Editor
+@param newName new name to be shown
+@type str
 """
 if newName:
 if self.filenameOnly:
 tabName = os.path.basename(newName)
 else:
 def _modificationStatusChanged(self, m, editor):
 """
 Protected slot to handle the modificationStatusChanged signal.
-@param m flag indicating the modification status (boolean)
+@param m flag indicating the modification status
+@type bool
 @param editor editor window changed
+@type Editor
 """
 for tw in self.tabWidgets:
 if tw.hasEditor(editor):
 break
 index = tw.indexOf(editor)
 def _syntaxErrorToggled(self, editor):
 """
 Protected slot to handle the syntaxerrorToggled signal.
 @param editor editor that sent the signal
+@type Editor
 """
 for tw in self.tabWidgets:
 if tw.hasEditor(editor):
 break
 index = tw.indexOf(editor)
 [int(size / len(self.tabWidgets))] * len(self.tabWidgets))
 self.splitRemoveAct.setEnabled(True)
 self.nextSplitAct.setEnabled(True)
 self.prevSplitAct.setEnabled(True)
-def removeSplit(self):
+def removeSplit(self, index=-1):
 """
-Public method used to remove the current split view.
+Public method used to remove the current split view or a split view
+by index.
-@return flag indicating successfull removal
+@param index index of the split to be removed (-1 means to
+delete the current split)
+@type int
+@return flag indicating successful deletion
+@rtype bool
 """
 if len(self.tabWidgets) > 1:
-tw = self.currentTabWidget
+if index == -1:
+tw = self.currentTabWidget
+else:
+if index < len(self.tabWidgets):
+tw = self.tabWidgets[index]
+else:
+tw = self.tabWidgets[-1]
 res = True
 savedEditors = tw.editors[:]
 for editor in savedEditors:
 res &= self.closeEditor(editor)
 if res:
 self.prevSplitAct.setEnabled(False)
 return True
 return False
+def splitCount(self):
+"""
+Public method to get the number of splitted views.
+@return number of splitted views
+@rtype int
+"""
+return len(self.tabWidgets)
+def setSplitCount(self, count):
+"""
+Public method to set the number of split views.
+@param count number of split views
+@type int
+"""
+if count > self.splitCount():
+while self.splitCount() < count:
+self.addSplit()
+elif count < self.splitCount():
+while self.splitCount() > count:
+# use an arbitrarily large index to remove the last one
+self.removeSplit(index=100)
 def getSplitOrientation(self):
 """
 Public method to get the orientation of the split view.
-@return orientation of the split (Qt.Horizontal or Qt.Vertical)
+@return orientation of the split
+@rtype Qt.Horizontal or Qt.Vertical
 """
 return self.__splitter.orientation()
 def setSplitOrientation(self, orientation):
 """
 Public method used to set the orientation of the split view.
 @param orientation orientation of the split
-(Qt.Horizontal or Qt.Vertical)
+@type Qt.Horizontal or Qt.Vertical
 """
 self.__splitter.setOrientation(orientation)
 def nextSplit(self):
 """
 def __currentChanged(self, index):
 """
 Private slot to handle the currentChanged signal.
-@param index index of the current tab (integer)
+@param index index of the current tab
+@type int
 """
 if index == -1 or not self.editors:
 return
 editor = self.activeWindow()
 def eventFilter(self, watched, event):
 """
 Public method called to filter the event queue.
-@param watched the QObject being watched (QObject)
+@param watched the QObject being watched
-@param event the event that occurred (QEvent)
+@type QObject
+@param event the event that occurred
+@type QEvent
 @return always False
+@rtype bool
 """
 if event.type() == QEvent.MouseButtonPress and \
 not event.button() == Qt.RightButton:
 switched = True
 self.currentTabWidget.showIndicator(False)
 def getTabWidgetById(self, id_):
 """
 Public method to get a reference to a tab widget knowing its ID.
-@param id_ id of the tab widget (long)
+@param id_ id of the tab widget
-@return reference to the tab widget (TabWidget)
+@type int
+@return reference to the tab widget
+@rtype TabWidget
 """
 for tw in self.tabWidgets:
 if id(tw) == id_:
 return tw
 return None
+def getOpenEditorsForSession(self):
+"""
+Public method to get a lists of all open editors.
+The returned list contains one list per split view. If the view manager
+cannot split the view, only one list of editors is returned.
+@return list of list of editor references
+@rtype list of list of Editor
+"""
+editorLists = []
+for tabWidget in self.tabWidgets:
+editors = []
+for index in range(tabWidget.count()):
+widget = tabWidget.widget(index)
+if isinstance(widget, EditorAssembly):
+editor = widget.getEditor()
+editors.append(editor)
+editorLists.append(editors)
+return editorLists

Mercurial Repositories > eric / file comparison

comparison: Plugins/ViewManagerPlugins/Tabview/Tabview.py

Plugins/ViewManagerPlugins/Tabview/Tabview.py