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

-:6e09a9a73cb7
+:8b49d3e0b4c8
 from ViewManager.ViewManager import ViewManager
 import QScintilla.Editor
 from QScintilla.Editor import Editor
+from QScintilla.EditorAssembly import EditorAssembly
 import UI.PixmapCache
 class StackedWidget(QStackedWidget):
 """
 def __init__(self, parent):
 """
 Constructor
-@param parent parent widget (QWidget)
+@param parent parent widget
+@type QWidget
 """
 super(StackedWidget, self).__init__(parent)
 self.editors = []
 def addWidget(self, assembly):
 """
 Public method to add a new widget.
 @param assembly editor assembly object to be added
-(QScintilla.EditorAssembly.EditorAssembly)
+@type QScintilla.EditorAssembly.EditorAssembly
 """
 editor = assembly.getEditor()
 super(StackedWidget, self).addWidget(assembly)
 if editor not in self.editors:
 self.editors.append(editor)
 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):
 self.editors.remove(widget)
 widget = widget.parent()
 super(StackedWidget, self).removeWidget(widget)
 def currentWidget(self):
 """
 Public method to get a reference to the current editor.
-@return reference to the current editor (Editor)
+@return reference to the current editor
+@rtype Editor
 """
 widget = super(StackedWidget, self).currentWidget()
 if widget is not None:
 widget = widget.getEditor()
 return widget
 def setCurrentWidget(self, widget):
 """
 Public method to set the current widget.
-@param widget widget to be made current (QWidget)
+@param widget widget to be made current
+@type QWidget
 """
 if widget is not None:
 if isinstance(widget, QScintilla.Editor.Editor):
 self.editors.remove(widget)
 self.editors.insert(0, widget)
 def setCurrentIndex(self, index):
 """
 Public method to set the current widget by its index.
-@param index index of widget to be made current (integer)
+@param index index of widget to be made current
+@type int
 """
 widget = self.widget(index)
 if widget is not None:
 self.setCurrentWidget(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 stacked widget.
+@rtype bool
 """
 return editor in self.editors
 def firstEditor(self):
 """
 Public method to retrieve the first editor in the list of managed
 editors.
-@return first editor in list (QScintilla.Editor.Editor)
+@return first editor in list
+@rtype QScintilla.Editor.Editor
 """
 return len(self.editors) and self.editors[0] or None
 class Listspace(ViewManager):
 def __init__(self, parent):
 """
 Constructor
-@param parent parent widget (QWidget)
+@param parent parent widget
+@type QWidget
 """
 self.stacks = []
 self.__splitter = QSplitter(parent)
 ViewManager.__init__(self)
 def __showMenu(self, point):
 """
 Private slot to handle the customContextMenuRequested signal of
 the viewlist.
-@param point position to open the menu at (QPoint)
+@param point position to open the menu at
+@type QPoint
 """
 if self.editors:
 itm = self.viewlist.itemAt(point)
 if itm is not None:
 row = self.viewlist.row(itm)
 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.
+@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
 ind = self.editors.index(win)
 itm = self.viewlist.takeItem(ind)
 if itm:
 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
 if not QFileInfo(fn).isWritable():
 txt = self.tr("{0} (ro)").format(txt)
 itm = QListWidgetItem(txt)
 itm.setToolTip(fn)
 self.viewlist.addItem(itm)
-self.currentStack.addWidget(win)
+if indexes:
-self.currentStack.setCurrentWidget(win)
+if indexes[0] < len(self.stacks):
+stack = self.stacks[indexes[0]]
+else:
+stack = self.stacks[-1]
+stack.addWidget(win)
+else:
+self.currentStack.addWidget(win)
+self.currentStack.setCurrentWidget(win)
 editor.captionChanged.connect(self.__captionChange)
 editor.cursorLineChanged.connect(self.__cursorLineChanged)
 index = self.editors.index(editor)
 self.viewlist.setCurrentRow(index)
 """
 Private method to handle caption change signals from the editor.
 Updates the listwidget text to reflect the new caption information.
-@param cap Caption for the editor (string)
+@param cap Caption for the editor
+@type str
 @param editor Editor to update the caption for
+@type Editor
 """
 fn = editor.getFileName()
 if fn:
 self.setEditorName(editor, 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:
 fn = editor.getFileName()
 if fn:
 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 string
 """
 editor = win.getEditor()
 for stack in self.stacks:
 if stack.hasEditor(editor):
 stack.setCurrentWidget(win)
 def __showSelectedView(self, row):
 """
 Private slot called to show a view selected in the list.
-@param row row number of the item clicked on (integer)
+@param row row number of the item clicked on
+@type int
 """
 if row != -1:
 self._showView(self.editors[row].parent())
 self._checkActions(self.editors[row])
 def activeWindow(self):
 """
 Public method to return the active (i.e. current) window.
 @return reference to the active editor
+@rtype EditorAssembly
 """
 return self.currentStack.currentWidget()
 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:
 currentRow = self.viewlist.currentRow()
 index = self.editors.index(editor)
 txt = os.path.basename(newName)
 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
 """
 currentRow = self.viewlist.currentRow()
 index = self.editors.index(editor)
 keys = []
 if m:
 def _syntaxErrorToggled(self, editor):
 """
 Protected slot to handle the syntaxerrorToggled signal.
 @param editor editor that sent the signal
+@type Editor
 """
 currentRow = self.viewlist.currentRow()
 index = self.editors.index(editor)
 keys = []
 if editor.isModified():
 [int(size / len(self.stacks))] * len(self.stacks))
 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.stacks) > 1:
-stack = self.currentStack
+if index == -1:
+stack = self.currentStack
+else:
+if index < len(self.stacks):
+stack = self.stacks[index]
+else:
+stack = self.stacks[-1]
 res = True
 savedEditors = stack.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.stacks)
+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.stackArea.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.stackArea.setOrientation(orientation)
 def nextSplit(self):
 """
 def __currentChanged(self, index):
 """
 Private slot to handle the currentChanged signal.
 @param index index of the current editor
+@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
+@type QObject
 @param event the event that occurred
+@type QEvent
 @return flag indicating, if we handled the event
+@rtype bool
 """
 if event.type() == QEvent.MouseButtonPress and \
 not event.button() == Qt.RightButton:
 switched = True
 if isinstance(watched, QStackedWidget):
 else:
 self.changeCaption.emit("")
 self.editorChangedEd.emit(aw)
 return False
+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 stack in self.stacks:
+editors = []
+for index in range(stack.count()):
+widget = stack.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/Listspace/Listspace.py

Plugins/ViewManagerPlugins/Listspace/Listspace.py