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

-:9986ec0e559a
+:10516539f238
 from __future__ import unicode_literals    # __IGNORE_WARNING__
 import os
-from PyQt4.QtCore import QPoint, QFileInfo, pyqtSignal, QEvent, QByteArray, QMimeData, Qt
+from PyQt4.QtCore import QPoint, QFileInfo, pyqtSignal, QEvent, QByteArray, \
-from PyQt4.QtGui import QWidget, QColor, QHBoxLayout, QDrag, QPixmap, QSplitter, \
+QMimeData, Qt
-QTabBar, QApplication, QToolButton, QMenu, QLabel
+from PyQt4.QtGui import QWidget, QColor, QHBoxLayout, QDrag, QPixmap, \
+QSplitter, QTabBar, QApplication, QToolButton, QMenu, QLabel
 from E5Gui.E5Application import e5App
 from ViewManager.ViewManager import ViewManager
 class TabBar(E5WheelTabBar):
 """
 Class implementing a customized tab bar supporting drag & drop.
-@signal tabMoveRequested(int, int) emitted to signal a tab move request giving
+@signal tabMoveRequested(int, int) emitted to signal a tab move request
-the old and new index position
+giving the old and new index position
-@signal tabRelocateRequested(str, int, int) emitted to signal a tab relocation
+@signal tabRelocateRequested(str, int, int) emitted to signal a tab
-request giving the string encoded id of the old tab widget, the index in
+relocation request giving the string encoded id of the old tab widget,
-the old tab widget and the new index position
+the index in the old tab widget and the new index position
 @signal tabCopyRequested(str, int, int) emitted to signal a clone request
 giving the string encoded id of the source tab widget, the index in the
 source tab widget and the new index position
 @signal tabCopyRequested(int, int) emitted to signal a clone request giving
 the old and new index position
 mimeData = QMimeData()
 index = self.tabAt(event.pos())
 mimeData.setText(self.tabText(index))
 mimeData.setData("action", "tab-reordering")
 mimeData.setData("tabbar-id", str(id(self)))
-mimeData.setData("source-index",
+mimeData.setData(
-QByteArray.number(self.tabAt(self.__dragStartPos)))
+"source-index",
+QByteArray.number(self.tabAt(self.__dragStartPos)))
 mimeData.setData("tabwidget-id", str(id(self.parentWidget())))
 drag.setMimeData(mimeData)
 if event.modifiers() == Qt.KeyboardModifiers(Qt.ShiftModifier):
 drag.exec_(Qt.DropActions(Qt.CopyAction))
 elif event.modifiers() == Qt.KeyboardModifiers(Qt.NoModifier):
 fromIndex = mimeData.data("source-index").toInt()[0]
 toIndex = self.tabAt(event.pos())
 if oldID != id(self):
 parentID = int(mimeData.data("tabwidget-id"))
 if event.proposedAction() == Qt.MoveAction:
-self.tabRelocateRequested.emit(str(parentID), fromIndex, toIndex)
+self.tabRelocateRequested.emit(
+str(parentID), fromIndex, toIndex)
 event.acceptProposedAction()
 elif event.proposedAction() == Qt.CopyAction:
 self.tabCopyRequested[str, int, int].emit(
 str(parentID), fromIndex, toIndex)
 event.acceptProposedAction()
 if isMacPlatform():
 self.setDocumentMode(True)
 self.__tabBar.tabMoveRequested.connect(self.moveTab)
 self.__tabBar.tabRelocateRequested.connect(self.__relocateTab)
-self.__tabBar.tabCopyRequested[str, int, int].connect(self.__copyTabOther)
+self.__tabBar.tabCopyRequested[str, int, int].connect(
+self.__copyTabOther)
 self.__tabBar.tabCopyRequested[int, int].connect(self.__copyTab)
 self.vm = vm
 self.editors = []
 if Preferences.getUI("SingleCloseButton") or \
 not hasattr(self, 'setTabsClosable'):
 self.closeButton = QToolButton(self)
 self.closeButton.setIcon(UI.PixmapCache.getIcon("close.png"))
-self.closeButton.setToolTip(self.trUtf8("Close the current editor"))
+self.closeButton.setToolTip(
+self.trUtf8("Close the current editor"))
 self.closeButton.setEnabled(False)
 self.closeButton.clicked[bool].connect(self.__closeButtonClicked)
 self.rightCornerWidgetLayout.addWidget(self.closeButton)
 else:
 self.tabCloseRequested.connect(self.__closeRequested)
 self.contextMenuIndex = -1
 self.setTabContextMenuPolicy(Qt.CustomContextMenu)
 self.customTabContextMenuRequested.connect(self.__showContextMenu)
-ericPic = QPixmap(os.path.join(getConfig('ericPixDir'), 'eric_small.png'))
+ericPic = QPixmap(
+os.path.join(getConfig('ericPixDir'), 'eric_small.png'))
 self.emptyLabel = QLabel()
 self.emptyLabel.setPixmap(ericPic)
 self.emptyLabel.setAlignment(Qt.AlignVCenter | Qt.AlignHCenter)
-super(TabWidget, self).addTab(self.emptyLabel, UI.PixmapCache.getIcon("empty.png"), "")
+super(TabWidget, self).addTab(self.emptyLabel,
+UI.PixmapCache.getIcon("empty.png"), "")
 def __initMenu(self):
 """
 Private method to initialize the tab context menu.
 """
 self.trUtf8('Move Last'), self.__contextMenuMoveLast)
 self.__menu.addSeparator()
 self.__menu.addAction(UI.PixmapCache.getIcon("tabClose.png"),
 self.trUtf8('Close'), self.__contextMenuClose)
 self.closeOthersMenuAct = self.__menu.addAction(
-UI.PixmapCache.getIcon("tabCloseOther.png"), self.trUtf8("Close Others"),
+UI.PixmapCache.getIcon("tabCloseOther.png"),
-self.__contextMenuCloseOthers)
+self.trUtf8("Close Others"), self.__contextMenuCloseOthers)
-self.__menu.addAction(self.trUtf8('Close All'), self.__contextMenuCloseAll)
+self.__menu.addAction(
+self.trUtf8('Close All'), self.__contextMenuCloseAll)
 self.__menu.addSeparator()
 self.saveMenuAct = \
 self.__menu.addAction(UI.PixmapCache.getIcon("fileSave.png"),
 self.trUtf8('Save'), self.__contextMenuSave)
 self.__menu.addAction(UI.PixmapCache.getIcon("fileSaveAs.png"),
 self.__contextMenuOpenRejections)
 self.__menu.addSeparator()
 self.__menu.addAction(UI.PixmapCache.getIcon("print.png"),
 self.trUtf8('Print'), self.__contextMenuPrintFile)
 self.__menu.addSeparator()
-self.copyPathAct = self.__menu.addAction(self.trUtf8("Copy Path to Clipboard"),
+self.copyPathAct = self.__menu.addAction(
+self.trUtf8("Copy Path to Clipboard"),
 self.__contextMenuCopyPathToClipboard)
 def __showContextMenu(self, coord, index):
 """
 Private slot to show the tab context menu.
 @param index index of the tab the menu is requested for (integer)
 """
 if self.editors:
 self.contextMenuEditor = self.widget(index).getEditor()
 if self.contextMenuEditor:
-self.saveMenuAct.setEnabled(self.contextMenuEditor.isModified())
+self.saveMenuAct.setEnabled(
+self.contextMenuEditor.isModified())
 fileName = self.contextMenuEditor.getFileName()
 self.copyPathAct.setEnabled(bool(fileName))
 if fileName:
 rej = "{0}.rej".format(fileName)
 self.openRejectionsMenuAct.setEnabled(os.path.exists(rej))
 def __captionChange(self, cap, editor):
 """
 Private slot to handle Caption change signals from the editor.
-Updates the tab text and tooltip text to reflect the new caption information.
+Updates the tab text and tooltip text to reflect the new caption
+information.
 @param cap Caption for the editor
 @param editor Editor to update the caption for
 """
 fn = editor.getFileName()
 if Preferences.getUI("TabViewManagerFilenameOnly"):
 txt = os.path.basename(fn)
 else:
 txt = e5App().getObject("Project").getRelativePath(fn)
-maxFileNameChars = Preferences.getUI("TabViewManagerFilenameLength")
+maxFileNameChars = Preferences.getUI(
+"TabViewManagerFilenameLength")
 if len(txt) > maxFileNameChars:
 txt = "...{0}".format(txt[-maxFileNameChars:])
 if editor.isReadOnly():
 txt = self.trUtf8("{0} (ro)").format(txt)
 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)
 """
 editor = self.sender()
-if editor:
+if editor and isinstance(editor, QScintilla.Editor.Editor):
 fn = editor.getFileName()
 if fn:
 self.vm.editorLineChanged.emit(fn, lineno + 1)
 def removeWidget(self, object):
 index = self.indexOf(object)
 if index > -1:
 self.removeTab(index)
 if not self.editors:
-super(TabWidget, self).addTab(self.emptyLabel, UI.PixmapCache.getIcon("empty.png"), "")
+super(TabWidget, self).addTab(
+self.emptyLabel, UI.PixmapCache.getIcon("empty.png"), "")
 self.emptyLabel.show()
 if self.closeButton:
 self.closeButton.setEnabled(False)
 else:
 self.setTabsClosable(False)
 @param targetIndex index position to place it to (integer)
 """
 tw = self.vm.getTabWidgetById(int(sourceId))
 if tw is not None:
 editor = tw.widget(sourceIndex).getEditor()
-newEditor, assembly = self.vm.cloneEditor(editor, editor.getFileType(),
+newEditor, assembly = self.vm.cloneEditor(
-editor.getFileName())
+editor, editor.getFileType(), editor.getFileName())
 self.vm.insertView(assembly, self, targetIndex,
 editor.getFileName(), editor.getNoName())
 def __copyTab(self, sourceIndex, targetIndex):
 """
 """
 self.vm.saveEditorsList(self.editors)
 def __contextMenuOpenRejections(self):
 """
-Private slot to open a rejections file associated with the selected tab.
+Private slot to open a rejections file associated with the selected
+tab.
 """
 if self.contextMenuEditor:
 fileName = self.contextMenuEditor.getFileName()
 if fileName:
 rej = "{0}.rej".format(fileName)
 if self.contextMenuEditor:
 self.vm.printEditor(self.contextMenuEditor)
 def __contextMenuCopyPathToClipboard(self):
 """
-Private method to copy the file name of the selected tab to the clipboard.
+Private method to copy the file name of the selected tab to the
+clipboard.
 """
 if self.contextMenuEditor:
 fn = self.contextMenuEditor.getFileName()
 if fn:
 cb = QApplication.clipboard()
 @signal editorChangedEd(Editor) emitted when the current editor has changed
 @signal lastEditorClosed() emitted after the last editor window was closed
 @signal editorOpened(str) emitted after an editor window was opened
 @signal editorOpenedEd(Editor) emitted after an editor window was opened
 @signal editorClosed(str) emitted just before an editor window gets closed
-@signal editorClosedEd(Editor) emitted just before an editor window gets closed
+@signal editorClosedEd(Editor) emitted just before an editor window gets
+closed
 @signal editorSaved(str) emitted after an editor window was saved
 @signal checkActions(Editor) emitted when some actions should be checked
 for their status
-@signal cursorChanged(Editor) emitted after the cursor position of the active
+@signal cursorChanged(Editor) emitted after the cursor position of the
-window has changed
+active window has changed
 @signal breakpointToggled(Editor) emitted when a breakpoint is toggled.
 @signal bookmarkToggled(Editor) emitted when a bookmark is toggled.
 @signal syntaxerrorToggled(Editor) emitted when a syntax error is toggled.
-@signal previewStateChanged(bool) emitted to signal a change in the preview state
+@signal previewStateChanged(bool) emitted to signal a change in the
+preview state
 @signal editorLanguageChanged(Editor) emitted to signal a change of an
 editors language
-@signal editorTextChanged(Editor) emitted to signal a change of an editor's text
+@signal editorTextChanged(Editor) emitted to signal a change of an
-@signal editorLineChanged(str,int) emitted to signal a change of an editor's
+editor's text
-current line (line is given one based)
+@signal editorLineChanged(str,int) emitted to signal a change of an
+editor's current line (line is given one based)
 """
 changeCaption = pyqtSignal(str)
 editorChanged = pyqtSignal(str)
 editorChangedEd = pyqtSignal(Editor)
 lastEditorClosed = pyqtSignal()
 def __init__(self, parent):
 """
 Constructor
 @param parent parent widget (QWidget)
-@param ui reference to the main user interface
-@param dbs reference to the debug server object
 """
 self.tabWidgets = []
 QSplitter.__init__(self, parent)
 ViewManager.__init__(self)
 tw.installEventFilter(self)
 tw.tabBar().installEventFilter(self)
 self.setOrientation(Qt.Vertical)
 self.__inRemoveView = False
-self.maxFileNameChars = Preferences.getUI("TabViewManagerFilenameLength")
+self.maxFileNameChars = Preferences.getUI(
+"TabViewManagerFilenameLength")
 self.filenameOnly = Preferences.getUI("TabViewManagerFilenameOnly")
 def canCascade(self):
 """
 Public method to signal if cascading of managed windows is available.
 """
 pass
 def _removeAllViews(self):
 """
-Protected method to remove all views (i.e. windows)
+Protected method to remove all views (i.e. windows).
 """
 for win in self.editors:
 self._removeView(win)
 def _removeView(self, win):
 """
-Protected method to remove a view (i.e. window)
+Protected method to remove a view (i.e. window).
 @param win editor window to be removed
 """
 self.__inRemoveView = True
 for tw in self.tabWidgets:
 self.__inRemoveView = False
 # if this was the last editor in this view, switch to the next, that
 # still has open editors
 for i in list(range(self.tabWidgets.index(tw), -1, -1)) + \
-list(range(self.tabWidgets.index(tw) + 1, len(self.tabWidgets))):
+list(range(self.tabWidgets.index(tw) + 1,
+len(self.tabWidgets))):
 if self.tabWidgets[i].hasEditors():
 self.currentTabWidget.showIndicator(False)
 self.currentTabWidget = self.tabWidgets[i]
 self.currentTabWidget.showIndicator(True)
 self.activeWindow().setFocus()
 self.changeCaption.emit("")
 self.editorChangedEd.emit(aw)
 def _addView(self, win, fn=None, noName=""):
 """
-Protected method to add a view (i.e. window)
+Protected method to add a view (i.e. window).
 @param win editor assembly to be added
 @param fn filename of this editor (string)
 @param noName name to be used for an unnamed editor (string)
 """
 self.changeCaption.emit("")
 self.editorChangedEd.emit(editor)
 def insertView(self, win, tabWidget, index, fn=None, noName=""):
 """
-Protected method to add a view (i.e. window)
+Protected method to add a view (i.e. window).
 @param win editor assembly to be inserted
-@param tabWidget reference to the tab widget to insert the editor into (TabWidget)
+@param tabWidget reference to the tab widget to insert the editor into
+(TabWidget)
 @param index index position to insert at (integer)
 @param fn filename of this editor (string)
 @param noName name to be used for an unnamed editor (string)
 """
 editor = win.getEditor()
 self._modificationStatusChanged(editor.isModified(), editor)
 self._checkActions(editor)
 def _showView(self, win, fn=None):
 """
-Protected method to show a view (i.e. window)
+Protected method to show a view (i.e. window).
 @param win editor assembly to be shown
 @param fn filename of this editor (string)
 """
 win.show()
 """
 pass
 def _initWindowActions(self):
 """
-Protected method to define the user interface actions for window handling.
+Protected method to define the user interface actions for window
+handling.
 """
 pass
 def setEditorName(self, editor, newName):
 """
 tw.tabBar().installEventFilter(self)
 if self.orientation() == Qt.Horizontal:
 size = self.width()
 else:
 size = self.height()
-self.setSizes([int(size / len(self.tabWidgets))] * len(self.tabWidgets))
+self.setSizes(
+[int(size / len(self.tabWidgets))] * len(self.tabWidgets))
 self.splitRemoveAct.setEnabled(True)
 self.nextSplitAct.setEnabled(True)
 self.prevSplitAct.setEnabled(True)
 def removeSplit(self):
 fn = editor.getFileName()
 if fn:
 self.changeCaption.emit(fn)
 if not self.__inRemoveView:
 self.editorChanged.emit(fn)
-self.editorLineChanged.emit(fn, editor.getCursorPosition()[0] + 1)
+self.editorLineChanged.emit(
+fn, editor.getCursorPosition()[0] + 1)
 else:
 self.changeCaption.emit("")
 self.editorChangedEd.emit(editor)
 def eventFilter(self, watched, event):
 elif isinstance(watched, QTabBar):
 switched = watched.parent() is not self.currentTabWidget
 self.currentTabWidget = watched.parent()
 if switched:
 index = self.currentTabWidget.selectTab(event.pos())
-switched = self.currentTabWidget.widget(index) is self.activeWindow()
+switched = self.currentTabWidget.widget(index) is \
+self.activeWindow()
 elif isinstance(watched, QScintilla.Editor.Editor):
 for tw in self.tabWidgets:
 if tw.hasEditor(watched):
 switched = tw is not self.currentTabWidget
 self.currentTabWidget = tw
 fn = aw.getFileName()
 if fn:
 self.changeCaption.emit(fn)
 if switched:
 self.editorChanged.emit(fn)
-self.editorLineChanged.emit(fn, aw.getCursorPosition()[0] + 1)
+self.editorLineChanged.emit(
+fn, aw.getCursorPosition()[0] + 1)
 else:
 self.changeCaption.emit("")
 self.editorChangedEd.emit(aw)
 return False
 """
 Public slot to handle the preferencesChanged signal.
 """
 ViewManager.preferencesChanged(self)
-self.maxFileNameChars = Preferences.getUI("TabViewManagerFilenameLength")
+self.maxFileNameChars = Preferences.getUI(
+"TabViewManagerFilenameLength")
 self.filenameOnly = Preferences.getUI("TabViewManagerFilenameOnly")
 for tabWidget in self.tabWidgets:
 for index in range(tabWidget.count()):
 editor = tabWidget.widget(index)
 fn = editor.getFileName()
 if fn:
 if self.filenameOnly:
 txt = os.path.basename(fn)
 else:
-txt = e5App().getObject("Project").getRelativePath(fn)
+txt = e5App().getObject("Project")\
+.getRelativePath(fn)
 if len(txt) > self.maxFileNameChars:
 txt = "...{0}".format(txt[-self.maxFileNameChars:])
 if not QFileInfo(fn).isWritable():
 txt = self.trUtf8("{0} (ro)").format(txt)
 tabWidget.setTabText(index, txt)

Mercurial Repositories > eric / file comparison

comparison: Plugins/ViewManagerPlugins/Tabview/Tabview.py

Plugins/ViewManagerPlugins/Tabview/Tabview.py