def __createLayout(self):
"""Creates the dialog layout"""
self.resize(450, 150)
self.setSizeGripEnabled(True)
verticalLayout = QVBoxLayout(self)
gridLayout = QGridLayout()
# Link
gridLayout.addWidget(QLabel('Link', self), 0, 0, 1, 1)
self.linkEdit = QLineEdit(self)
self.linkEdit.setClearButtonEnabled(True)
self.linkEdit.setToolTip(
'A link to a file or to an external web resource')
gridLayout.addWidget(self.linkEdit, 0, 1, 1, 1)
self.linkEdit.textChanged.connect(self.__validate)
self.fileButton = QPushButton(self)
self.fileButton.setText('...')
self.fileButton.setToolTip('Select an existing or non existing file')
gridLayout.addWidget(self.fileButton, 0, 2, 1, 1)
self.fileButton.clicked.connect(self.__onSelectPath)
self.createCheckBox = QCheckBox(
'Create a markdown file if does not exist', self)
self.createCheckBox.setChecked(False)
gridLayout.addWidget(self.createCheckBox, 1, 1, 1, 1)
self.createCheckBox.stateChanged.connect(self.__validate)
# Anchor
gridLayout.addWidget(QLabel('Anchor', self), 2, 0, 1, 1)
self.anchorEdit = QLineEdit(self)
self.anchorEdit.setClearButtonEnabled(True)
gridLayout.addWidget(self.anchorEdit, 2, 1, 1, 1)
self.anchorEdit.textChanged.connect(self.__validate)
# Title
titleLabel = QLabel('Title', self)
titleLabel.setAlignment(Qt.AlignTop)
gridLayout.addWidget(titleLabel, 3, 0, 1, 1)
self.titleEdit = QTextEdit()
self.titleEdit.setTabChangesFocus(True)
self.titleEdit.setAcceptRichText(False)
self.titleEdit.setFont(getZoomedMonoFont())
self.titleEdit.setToolTip(
'If provided then will be displayed in the rectangle')
gridLayout.addWidget(self.titleEdit, 3, 1, 1, 1)
# Buttons at the bottom
buttonBox = QDialogButtonBox(self)
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Ok)
self.__OKButton = buttonBox.button(QDialogButtonBox.Ok)
self.__OKButton.setDefault(True)
buttonBox.accepted.connect(self.accept)
buttonBox.rejected.connect(self.close)
verticalLayout.addLayout(gridLayout)
verticalLayout.addWidget(buttonBox)
self.linkEdit.setFocus()
def __createLayout(self):
"""Creates the dialog layout"""
self.resize(320, 120)
self.setSizeGripEnabled(True)
pluginVersion = getPluginVersionAndPath(self.__pluginHomeDir)
pylintVersion, pylintPath = getPylintVersionAndPath()
vboxLayout = QVBoxLayout(self)
hboxLayout = QHBoxLayout()
iconLabel = QLabel()
iconLabel.setPixmap(QPixmap(self.__pluginHomeDir + 'pylint.png'))
iconLabel.setScaledContents(True)
iconLabel.setFixedSize(48, 48)
hboxLayout.addWidget(iconLabel)
titleLabel = QLabel('<b>Codimension pylint plugin</b>')
titleLabel.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
titleLabel.setFixedHeight(48)
titleLabel.setAlignment(Qt.AlignCenter)
infoLabel = QLabel('<hr><br>More info:'
'<ul>'
'<li>Plugin<br>'
'Version: ' + pluginVersion + '<br>'
'Location: ' + self.__pluginHomeDir + '</li>'
'<li>Pylint<br>'
'Version: ' + pylintVersion + '<br>' +
'Location: ' + pylintPath + '</li>'
'</ul><br>')
hboxLayout.addWidget(titleLabel)
vboxLayout.addLayout(hboxLayout)
vboxLayout.addWidget(infoLabel)
self.__buttonBox = QDialogButtonBox(self)
self.__buttonBox.setOrientation(Qt.Horizontal)
self.__buttonBox.setStandardButtons(QDialogButtonBox.Ok)
self.__buttonBox.accepted.connect(self.close)
self.__buttonBox.rejected.connect(self.close)
vboxLayout.addWidget(self.__buttonBox)
def __createLayout(self):
"""Creates the dialog layout"""
self.resize(640, 420)
self.setSizeGripEnabled(True)
vboxLayout = QVBoxLayout(self)
hboxLayout = QHBoxLayout()
iconLabel = QLabel()
logoPath = os.path.dirname(os.path.abspath(__file__)) + \
os.path.sep + "svn-logo.png"
iconLabel.setPixmap(QPixmap(logoPath))
iconLabel.setScaledContents(True)
iconLabel.setFixedSize(48, 48)
hboxLayout.addWidget(iconLabel)
titleLabel = QLabel("Codimension SVN plugin settings")
titleLabel.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
titleLabel.setFixedHeight(48)
titleLabel.setAlignment(Qt.AlignCenter)
hboxLayout.addWidget(titleLabel)
vboxLayout.addLayout(hboxLayout)
self.__tabWidget = QTabWidget(self)
self.__tabWidget.setFocusPolicy(Qt.NoFocus)
ideWide = self.__createIDEWide()
self.__tabWidget.addTab(ideWide, "IDE Wide")
projectSpecific = self.__createProjectSpecific()
self.__tabWidget.addTab(projectSpecific, "Project Specific")
version = self.__createVersionWidget()
self.__tabWidget.addTab(version, "Versions")
vboxLayout.addWidget(self.__tabWidget)
# Buttons at the bottom
self.__buttonBox = QDialogButtonBox(self)
self.__buttonBox.setOrientation(Qt.Horizontal)
self.__buttonBox.setStandardButtons(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.__buttonBox.accepted.connect(self.userAccept)
self.__buttonBox.rejected.connect(self.close)
vboxLayout.addWidget(self.__buttonBox)
class FlowUIWidget(QWidget):
"""The widget which goes along with the text editor"""
def __init__(self, editor, parent):
QWidget.__init__(self, parent)
# It is always not visible at the beginning because there is no
# editor content at the start
self.setVisible(False)
self.__editor = editor
self.__parentWidget = parent
self.__connected = False
self.__needPathUpdate = False
self.cflowSettings = getCflowSettings(self)
self.__displayProps = (self.cflowSettings.hidedocstrings,
self.cflowSettings.hidecomments,
self.cflowSettings.hideexcepts,
Settings()['smartZoom'])
hLayout = QHBoxLayout()
hLayout.setContentsMargins(0, 0, 0, 0)
hLayout.setSpacing(0)
vLayout = QVBoxLayout()
vLayout.setContentsMargins(0, 0, 0, 0)
vLayout.setSpacing(0)
# Make pylint happy
self.__toolbar = None
self.__navBar = None
self.__cf = None
self.__canvas = None
self.__validGroups = []
self.__allGroupId = set()
# Create the update timer
self.__updateTimer = QTimer(self)
self.__updateTimer.setSingleShot(True)
self.__updateTimer.timeout.connect(self.process)
vLayout.addWidget(self.__createNavigationBar())
vLayout.addWidget(self.__createStackedViews())
hLayout.addLayout(vLayout)
hLayout.addWidget(self.__createToolbar())
self.setLayout(hLayout)
self.updateSettings()
# Connect to the change file type signal
self.__mainWindow = GlobalData().mainWindow
editorsManager = self.__mainWindow.editorsManagerWidget.editorsManager
editorsManager.sigFileTypeChanged.connect(self.__onFileTypeChanged)
Settings().sigHideDocstringsChanged.connect(
self.__onHideDocstringsChanged)
Settings().sigHideCommentsChanged.connect(self.__onHideCommentsChanged)
Settings().sigHideExceptsChanged.connect(self.__onHideExceptsChanged)
Settings().sigSmartZoomChanged.connect(self.__onSmartZoomChanged)
self.setSmartZoomLevel(Settings()['smartZoom'])
def getParentWidget(self):
return self.__parentWidget
def view(self):
"""Provides a reference to the current view"""
return self.smartViews.currentWidget()
def scene(self):
"""Provides a reference to the current scene"""
return self.view().scene
def __createToolbar(self):
"""Creates the toolbar"""
self.__toolbar = QToolBar(self)
self.__toolbar.setOrientation(Qt.Vertical)
self.__toolbar.setMovable(False)
self.__toolbar.setAllowedAreas(Qt.RightToolBarArea)
self.__toolbar.setIconSize(QSize(16, 16))
self.__toolbar.setFixedWidth(30)
self.__toolbar.setContentsMargins(0, 0, 0, 0)
# Buttons
saveAsMenu = QMenu(self)
saveAsSVGAct = saveAsMenu.addAction(getIcon('filesvg.png'),
'Save as SVG...')
saveAsSVGAct.triggered.connect(self.onSaveAsSVG)
saveAsPDFAct = saveAsMenu.addAction(getIcon('filepdf.png'),
'Save as PDF...')
saveAsPDFAct.triggered.connect(self.onSaveAsPDF)
saveAsPNGAct = saveAsMenu.addAction(getIcon('filepixmap.png'),
'Save as PNG...')
saveAsPNGAct.triggered.connect(self.onSaveAsPNG)
saveAsMenu.addSeparator()
saveAsCopyToClipboardAct = saveAsMenu.addAction(
getIcon('copymenu.png'), 'Copy to clipboard')
saveAsCopyToClipboardAct.triggered.connect(self.copyToClipboard)
self.__saveAsButton = QToolButton(self)
self.__saveAsButton.setIcon(getIcon('saveasmenu.png'))
self.__saveAsButton.setToolTip('Save as')
self.__saveAsButton.setPopupMode(QToolButton.InstantPopup)
self.__saveAsButton.setMenu(saveAsMenu)
self.__saveAsButton.setFocusPolicy(Qt.NoFocus)
self.__levelUpButton = QToolButton(self)
self.__levelUpButton.setFocusPolicy(Qt.NoFocus)
self.__levelUpButton.setIcon(getIcon('levelup.png'))
self.__levelUpButton.setToolTip('Smart zoom level up (Shift+wheel)')
self.__levelUpButton.clicked.connect(self.onSmartZoomLevelUp)
self.__levelIndicator = QLabel('<b>0</b>', self)
self.__levelIndicator.setAlignment(Qt.AlignCenter)
self.__levelDownButton = QToolButton(self)
self.__levelDownButton.setFocusPolicy(Qt.NoFocus)
self.__levelDownButton.setIcon(getIcon('leveldown.png'))
self.__levelDownButton.setToolTip('Smart zoom level down (Shift+wheel)')
self.__levelDownButton.clicked.connect(self.onSmartZoomLevelDown)
fixedSpacer = QWidget()
fixedSpacer.setFixedHeight(10)
self.__hideDocstrings = QToolButton(self)
self.__hideDocstrings.setCheckable(True)
self.__hideDocstrings.setIcon(getIcon('hidedocstrings.png'))
self.__hideDocstrings.setToolTip('Show/hide docstrings')
self.__hideDocstrings.setFocusPolicy(Qt.NoFocus)
self.__hideDocstrings.setChecked(Settings()['hidedocstrings'])
self.__hideDocstrings.clicked.connect(self.__onHideDocstrings)
self.__hideComments = QToolButton(self)
self.__hideComments.setCheckable(True)
self.__hideComments.setIcon(getIcon('hidecomments.png'))
self.__hideComments.setToolTip('Show/hide comments')
self.__hideComments.setFocusPolicy(Qt.NoFocus)
self.__hideComments.setChecked(Settings()['hidecomments'])
self.__hideComments.clicked.connect(self.__onHideComments)
self.__hideExcepts = QToolButton(self)
self.__hideExcepts.setCheckable(True)
self.__hideExcepts.setIcon(getIcon('hideexcepts.png'))
self.__hideExcepts.setToolTip('Show/hide except blocks')
self.__hideExcepts.setFocusPolicy(Qt.NoFocus)
self.__hideExcepts.setChecked(Settings()['hideexcepts'])
self.__hideExcepts.clicked.connect(self.__onHideExcepts)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.__toolbar.addWidget(self.__saveAsButton)
self.__toolbar.addWidget(spacer)
self.__toolbar.addWidget(self.__levelUpButton)
self.__toolbar.addWidget(self.__levelIndicator)
self.__toolbar.addWidget(self.__levelDownButton)
self.__toolbar.addWidget(fixedSpacer)
self.__toolbar.addWidget(self.__hideDocstrings)
self.__toolbar.addWidget(self.__hideComments)
self.__toolbar.addWidget(self.__hideExcepts)
return self.__toolbar
def __createNavigationBar(self):
"""Creates the navigation bar"""
self.__navBar = ControlFlowNavigationBar(self)
return self.__navBar
def __createStackedViews(self):
"""Creates the graphics view"""
self.smartViews = QStackedWidget(self)
self.smartViews.setContentsMargins(0, 0, 0, 0)
self.smartViews.addWidget(CFGraphicsView(self.__navBar, self))
self.smartViews.addWidget(CFGraphicsView(self.__navBar, self))
return self.smartViews
def process(self):
"""Parses the content and displays the results"""
if not self.__connected:
self.__connectEditorSignals()
start = timer()
cf = getControlFlowFromMemory(self.__editor.text)
end = timer()
if cf.errors:
self.__navBar.updateInfoIcon(self.__navBar.STATE_BROKEN_UTD)
errors = []
for err in cf.errors:
if err[0] == -1 and err[1] == -1:
errors.append(err[2])
elif err[1] == -1:
errors.append('[' + str(err[0]) + ':] ' + err[2])
elif err[0] == -1:
errors.append('[:' + str(err[1]) + '] ' + err[2])
else:
errors.append('[' + str(err[0]) + ':' +
str(err[1]) + '] ' + err[2])
self.__navBar.setErrors(errors)
return
self.__cf = cf
if self.isDebugMode():
logging.info('Parsed file: %s', formatFlow(str(self.__cf)))
logging.info('Parse timing: %f', end - start)
# Collect warnings (parser + CML warnings) and valid groups
self.__validGroups = []
self.__allGroupId = set()
allWarnings = self.__cf.warnings + \
CMLVersion.validateCMLComments(self.__cf,
self.__validGroups,
self.__allGroupId)
# That will clear the error tooltip as well
self.__navBar.updateInfoIcon(self.__navBar.STATE_OK_UTD)
if allWarnings:
warnings = []
for warn in allWarnings:
if warn[0] == -1 and warn[1] == -1:
warnings.append(warn[2])
elif warn[1] == -1:
warnings.append('[' + str(warn[0]) + ':] ' + warn[2])
elif warn[0] == -1:
warnings.append('[:' + str(warn[1]) + '] ' + warn[2])
else:
warnings.append('[' + str(warn[0]) + ':' +
str(warn[1]) + '] ' + warn[2])
self.__navBar.setWarnings(warnings)
else:
self.__navBar.clearWarnings()
self.redrawScene()
def __cleanupCanvas(self):
"""Cleans up the canvas"""
if self.__canvas is not None:
self.__canvas.cleanup()
self.__canvas = None
for item in self.scene().items():
item.cleanup()
self.scene().clear()
def redrawScene(self):
"""Redraws the scene"""
smartZoomLevel = Settings()['smartZoom']
self.cflowSettings = getCflowSettings(self)
if self.dirty():
self.__displayProps = (self.cflowSettings.hidedocstrings,
self.cflowSettings.hidecomments,
self.cflowSettings.hideexcepts,
smartZoomLevel)
self.cflowSettings.itemID = 0
self.cflowSettings = tweakSmartSettings(self.cflowSettings,
smartZoomLevel)
try:
fileName = self.__parentWidget.getFileName()
if not fileName:
fileName = self.__parentWidget.getShortName()
collapsedGroups = getCollapsedGroups(fileName)
# Top level canvas has no adress and no parent canvas
self.__cleanupCanvas()
self.__canvas = VirtualCanvas(self.cflowSettings, None, None,
self.__validGroups, collapsedGroups,
None)
lStart = timer()
self.__canvas.layoutModule(self.__cf)
lEnd = timer()
self.__canvas.setEditor(self.__editor)
width, height = self.__canvas.render()
rEnd = timer()
self.scene().setSceneRect(0, 0, width, height)
self.__canvas.draw(self.scene(), 0, 0)
dEnd = timer()
if self.isDebugMode():
logging.info('Redrawing is done. Size: %d x %d', width, height)
logging.info('Layout timing: %f', lEnd - lStart)
logging.info('Render timing: %f', rEnd - lEnd)
logging.info('Draw timing: %f', dEnd - rEnd)
except Exception as exc:
logging.error(str(exc))
raise
def onFlowZoomChanged(self):
"""Triggered when a flow zoom is changed"""
if self.__cf:
selection = self.scene().serializeSelection()
firstOnScreen = self.scene().getFirstLogicalItem()
self.cflowSettings.onFlowZoomChanged()
self.redrawScene()
self.updateNavigationToolbar('')
self.scene().restoreSelectionByID(selection)
self.__restoreScroll(firstOnScreen)
def __onFileTypeChanged(self, fileName, uuid, newFileType):
"""Triggered when a buffer content type has changed"""
if self.__parentWidget.getUUID() != uuid:
return
if not isPythonMime(newFileType):
self.__disconnectEditorSignals()
self.__updateTimer.stop()
self.__cleanupCanvas()
self.__cf = None
self.__validGroups = []
self.setVisible(False)
self.__navBar.updateInfoIcon(self.__navBar.STATE_UNKNOWN)
return
# Update the bar and show it
self.setVisible(True)
self.process()
# The buffer type change event comes when the content is loaded first
# time. So this is a good point to restore the position
_, _, _, cflowHPos, cflowVPos = getFilePosition(fileName)
self.setScrollbarPositions(cflowHPos, cflowVPos)
def terminate(self):
"""Called when a tab is closed"""
if self.__updateTimer.isActive():
self.__updateTimer.stop()
self.__updateTimer.deleteLater()
self.__disconnectEditorSignals()
self.__mainWindow = GlobalData().mainWindow
editorsManager = self.__mainWindow.editorsManagerWidget.editorsManager
editorsManager.sigFileTypeChanged.disconnect(self.__onFileTypeChanged)
Settings().sigHideDocstringsChanged.disconnect(
self.__onHideDocstringsChanged)
Settings().sigHideCommentsChanged.disconnect(self.__onHideCommentsChanged)
Settings().sigHideExceptsChanged.disconnect(self.__onHideExceptsChanged)
Settings().sigSmartZoomChanged.disconnect(self.__onSmartZoomChanged)
# Helps GC to collect more
self.__cleanupCanvas()
for index in range(self.smartViews.count()):
self.smartViews.widget(index).terminate()
self.smartViews.widget(index).deleteLater()
self.smartViews.deleteLater()
self.__navBar.deleteLater()
self.__cf = None
self.__saveAsButton.menu().deleteLater()
self.__saveAsButton.deleteLater()
self.__levelUpButton.clicked.disconnect(self.onSmartZoomLevelUp)
self.__levelUpButton.deleteLater()
self.__levelDownButton.clicked.disconnect(self.onSmartZoomLevelDown)
self.__levelDownButton.deleteLater()
self.__hideDocstrings.clicked.disconnect(self.__onHideDocstrings)
self.__hideDocstrings.deleteLater()
self.__hideComments.clicked.disconnect(self.__onHideComments)
self.__hideComments.deleteLater()
self.__hideExcepts.clicked.disconnect(self.__onHideExcepts)
self.__hideExcepts.deleteLater()
self.__toolbar.deleteLater()
self.__editor = None
self.__parentWidget = None
self.cflowSettings = None
self.__displayProps = None
def __connectEditorSignals(self):
"""When it is a python file - connect to the editor signals"""
if not self.__connected:
self.__editor.cursorPositionChanged.connect(
self.__cursorPositionChanged)
self.__editor.textChanged.connect(self.__onBufferChanged)
self.__connected = True
def __disconnectEditorSignals(self):
"""Disconnect the editor signals when the file is not a python one"""
if self.__connected:
self.__editor.cursorPositionChanged.disconnect(
self.__cursorPositionChanged)
self.__editor.textChanged.disconnect(self.__onBufferChanged)
self.__connected = False
def __cursorPositionChanged(self):
"""Cursor position changed"""
# The timer should be reset only in case if the redrawing was delayed
if self.__updateTimer.isActive():
self.__updateTimer.stop()
self.__updateTimer.start(IDLE_TIMEOUT)
def __onBufferChanged(self):
"""Triggered to update status icon and to restart the timer"""
self.__updateTimer.stop()
if self.__navBar.getCurrentState() in [self.__navBar.STATE_OK_UTD,
self.__navBar.STATE_OK_CHN,
self.__navBar.STATE_UNKNOWN]:
self.__navBar.updateInfoIcon(self.__navBar.STATE_OK_CHN)
else:
self.__navBar.updateInfoIcon(self.__navBar.STATE_BROKEN_CHN)
self.__updateTimer.start(IDLE_TIMEOUT)
def redrawNow(self):
"""Redraw the diagram regardless of the timer"""
if self.__updateTimer.isActive():
self.__updateTimer.stop()
self.process()
def generateNewGroupId(self):
"""Generates a new group ID (string)"""
# It can also consider the current set of the groups: valid + invalid
# and generate an integer id which is shorter
for vacantGroupId in range(1000):
groupId = str(vacantGroupId)
if not groupId in self.__allGroupId:
return groupId
# Last resort
return str(uuid.uuid1())
def updateNavigationToolbar(self, text):
"""Updates the toolbar text"""
if self.__needPathUpdate:
self.__navBar.setPath(text)
def updateSettings(self):
"""Updates settings"""
self.__needPathUpdate = Settings()['showCFNavigationBar']
self.__navBar.setPathVisible(self.__needPathUpdate)
self.__navBar.setPath('')
def highlightAtAbsPos(self, absPos, line, pos):
"""Scrolls the view to the item closest to absPos and selects it.
line and pos are 1-based
"""
item, _ = self.scene().getNearestItem(absPos, line, pos)
if item:
GlobalData().mainWindow.setFocusToFloatingRenderer()
self.scene().clearSelection()
item.setSelected(True)
self.view().scrollTo(item)
self.setFocus()
def setFocus(self):
"""Sets the focus"""
self.view().setFocus()
@staticmethod
def __getDefaultSaveDir():
"""Provides the default directory to save files to"""
project = GlobalData().project
if project.isLoaded():
return project.getProjectDir()
return QDir.currentPath()
def __selectFile(self, extension):
"""Picks a file of a certain extension"""
dialog = QFileDialog(self, 'Save flowchart as')
dialog.setFileMode(QFileDialog.AnyFile)
dialog.setLabelText(QFileDialog.Accept, "Save")
dialog.setNameFilter(extension.upper() + " files (*." +
extension.lower() + ")")
urls = []
for dname in QDir.drives():
urls.append(QUrl.fromLocalFile(dname.absoluteFilePath()))
urls.append(QUrl.fromLocalFile(QDir.homePath()))
project = GlobalData().project
if project.isLoaded():
urls.append(QUrl.fromLocalFile(project.getProjectDir()))
dialog.setSidebarUrls(urls)
suggestedFName = self.__parentWidget.getFileName()
if '.' in suggestedFName:
dotIndex = suggestedFName.rindex('.')
suggestedFName = suggestedFName[:dotIndex]
dialog.setDirectory(self.__getDefaultSaveDir())
dialog.selectFile(suggestedFName + "." + extension.lower())
dialog.setOption(QFileDialog.DontConfirmOverwrite, False)
dialog.setOption(QFileDialog.DontUseNativeDialog, True)
if dialog.exec_() != QDialog.Accepted:
return None
fileNames = dialog.selectedFiles()
fileName = os.path.abspath(str(fileNames[0]))
if os.path.isdir(fileName):
logging.error("A file must be selected")
return None
if "." not in fileName:
fileName += "." + extension.lower()
# Check permissions to write into the file or to a directory
if os.path.exists(fileName):
# Check write permissions for the file
if not os.access(fileName, os.W_OK):
logging.error("There is no write permissions for " + fileName)
return None
else:
# Check write permissions to the directory
dirName = os.path.dirname(fileName)
if not os.access(dirName, os.W_OK):
logging.error("There is no write permissions for the "
"directory " + dirName)
return None
if os.path.exists(fileName):
res = QMessageBox.warning(
self, "Save flowchart as",
"<p>The file <b>" + fileName + "</b> already exists.</p>",
QMessageBox.StandardButtons(QMessageBox.Abort |
QMessageBox.Save),
QMessageBox.Abort)
if res == QMessageBox.Abort or res == QMessageBox.Cancel:
return None
# All prerequisites are checked, return a file name
return fileName
def onSaveAsSVG(self):
"""Triggered on the 'Save as SVG' button"""
fileName = self.__selectFile("svg")
if fileName is None:
return False
try:
self.__saveAsSVG(fileName)
except Exception as excpt:
logging.error(str(excpt))
return False
return True
def __saveAsSVG(self, fileName):
"""Saves the flowchart as an SVG file"""
generator = QSvgGenerator()
generator.setFileName(fileName)
generator.setSize(QSize(self.scene().width(), self.scene().height()))
painter = QPainter(generator)
self.scene().render(painter)
painter.end()
def onSaveAsPDF(self):
"""Triggered on the 'Save as PDF' button"""
fileName = self.__selectFile("pdf")
if fileName is None:
return False
try:
self.__saveAsPDF(fileName)
except Exception as excpt:
logging.error(str(excpt))
return False
return True
def __saveAsPDF(self, fileName):
"""Saves the flowchart as an PDF file"""
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setPaperSize(QSizeF(self.scene().width(),
self.scene().height()), QPrinter.Point)
printer.setFullPage(True)
printer.setOutputFileName(fileName)
painter = QPainter(printer)
self.scene().render(painter)
painter.end()
def onSaveAsPNG(self):
"""Triggered on the 'Save as PNG' button"""
fileName = self.__selectFile("png")
if fileName is None:
return False
try:
self.__saveAsPNG(fileName)
except Exception as excpt:
logging.error(str(excpt))
return False
return True
def __getPNG(self):
"""Renders the scene as PNG"""
image = QImage(self.scene().width(), self.scene().height(),
QImage.Format_ARGB32_Premultiplied)
painter = QPainter(image)
# It seems that the better results are without antialiasing
# painter.setRenderHint( QPainter.Antialiasing )
self.scene().render(painter)
painter.end()
return image
def __saveAsPNG(self, fileName):
"""Saves the flowchart as an PNG file"""
image = self.__getPNG()
image.save(fileName, "PNG")
def copyToClipboard(self):
"""Copies the rendered scene to the clipboard as an image"""
image = self.__getPNG()
clip = QApplication.clipboard()
clip.setImage(image)
def getScrollbarPositions(self):
"""Provides the scrollbar positions"""
hScrollBar = self.view().horizontalScrollBar()
vScrollBar = self.view().verticalScrollBar()
return hScrollBar.value(), vScrollBar.value()
def setScrollbarPositions(self, hPos, vPos):
"""Sets the scrollbar positions for the view"""
self.view().horizontalScrollBar().setValue(hPos)
self.view().verticalScrollBar().setValue(vPos)
def __onHideDocstrings(self):
"""Triggered when a hide docstring button is pressed"""
Settings()['hidedocstrings'] = not Settings()['hidedocstrings']
def __onHideDocstringsChanged(self):
"""Signalled by settings"""
selection = self.scene().serializeSelection()
firstOnScreen = self.scene().getFirstLogicalItem()
settings = Settings()
self.__hideDocstrings.setChecked(settings['hidedocstrings'])
if self.__checkNeedRedraw():
self.scene().restoreSelectionByID(selection)
self.__restoreScroll(firstOnScreen)
def __onHideComments(self):
"""Triggered when a hide comments button is pressed"""
Settings()['hidecomments'] = not Settings()['hidecomments']
def __onHideCommentsChanged(self):
"""Signalled by settings"""
selection = self.scene().serializeSelection()
firstOnScreen = self.scene().getFirstLogicalItem()
settings = Settings()
self.__hideComments.setChecked(settings['hidecomments'])
if self.__checkNeedRedraw():
self.scene().restoreSelectionByID(selection)
self.__restoreScroll(firstOnScreen)
def __onHideExcepts(self):
"""Triggered when a hide except blocks button is pressed"""
Settings()['hideexcepts'] = not Settings()['hideexcepts']
def __onHideExceptsChanged(self):
"""Signalled by settings"""
selection = self.scene().serializeSelection()
firstOnScreen = self.scene().getFirstLogicalItem()
settings = Settings()
self.__hideExcepts.setChecked(settings['hideexcepts'])
if self.__checkNeedRedraw():
self.scene().restoreSelectionByTooltip(selection)
self.__restoreScroll(firstOnScreen)
def __checkNeedRedraw(self):
"""Redraws the scene if necessary when a display setting is changed"""
editorsManager = self.__mainWindow.editorsManagerWidget.editorsManager
if self.__parentWidget == editorsManager.currentWidget():
self.updateNavigationToolbar('')
self.process()
return True
return False
def dirty(self):
"""True if some other tab has switched display settings"""
settings = Settings()
return self.__displayProps[0] != settings['hidedocstrings'] or \
self.__displayProps[1] != settings['hidecomments'] or \
self.__displayProps[2] != settings['hideexcepts'] or \
self.__displayProps[3] != settings['smartZoom']
def onSmartZoomLevelUp(self):
"""Triggered when an upper smart zoom level was requested"""
Settings().onSmartZoomIn()
def onSmartZoomLevelDown(self):
"""Triggered when an lower smart zoom level was requested"""
Settings().onSmartZoomOut()
def setSmartZoomLevel(self, smartZoomLevel):
"""Sets the new smart zoom level"""
maxSmartZoom = Settings().MAX_SMART_ZOOM
if smartZoomLevel < 0 or smartZoomLevel > maxSmartZoom:
return
self.__levelIndicator.setText('<b>' + str(smartZoomLevel) + '</b>')
self.__levelIndicator.setToolTip(
getSmartZoomDescription(smartZoomLevel))
self.__levelUpButton.setEnabled(smartZoomLevel < maxSmartZoom)
self.__levelDownButton.setEnabled(smartZoomLevel > 0)
self.smartViews.setCurrentIndex(smartZoomLevel)
def __onSmartZoomChanged(self):
"""Triggered when a smart zoom changed"""
selection = self.scene().serializeSelection()
firstOnScreen = self.scene().getFirstLogicalItem()
self.setSmartZoomLevel(Settings()['smartZoom'])
if self.__checkNeedRedraw():
self.scene().restoreSelectionByTooltip(selection)
self.__restoreScroll(firstOnScreen)
def __restoreScroll(self, toItem):
"""Restores the view scrolling to the best possible position"""
if toItem:
lineRange = toItem.getLineRange()
absPosRange = toItem.getAbsPosRange()
item, _ = self.scene().getNearestItem(absPosRange[0],
lineRange[0], 0)
if item:
self.view().scrollTo(item, True)
self.view().horizontalScrollBar().setValue(0)
def validateCollapsedGroups(self, fileName):
"""Checks that there are no collapsed groups which are invalid"""
if self.__navBar.getCurrentState() != self.__navBar.STATE_OK_UTD:
return
collapsedGroups = getCollapsedGroups(fileName)
if collapsedGroups:
toBeDeleted = []
for groupId in collapsedGroups:
for validId, start, end in self.__validGroups:
del start
del end
if validId == groupId:
break
else:
toBeDeleted.append(groupId)
if toBeDeleted:
for groupId in toBeDeleted:
collapsedGroups.remove(groupId)
setCollapsedGroups(fileName, collapsedGroups)
else:
setCollapsedGroups(fileName, [])
def getDocItemByAnchor(self, anchor):
"""Provides the graphics item for the given anchor if so"""
return self.scene().getDocItemByAnchor(anchor)
@staticmethod
def isDebugMode():
"""True if it is a debug mode"""
return GlobalData().skin['debug']
class ControlFlowNavigationBar(QFrame):
"""Navigation bar at the top of the flow UI widget"""
STATE_OK_UTD = 0 # Parsed OK, control flow up to date
STATE_OK_CHN = 1 # Parsed OK, control flow changed
STATE_BROKEN_UTD = 2 # Parsed with errors, control flow up to date
STATE_BROKEN_CHN = 3 # Parsed with errors, control flow changed
STATE_UNKNOWN = 4
def __init__(self, parent):
QFrame.__init__(self, parent)
self.__infoIcon = None
self.__warningsIcon = None
self.__layout = None
self.__pathLabel = None
self.__createLayout()
self.__currentIconState = self.STATE_UNKNOWN
def __createLayout(self):
"""Creates the layout"""
self.setFixedHeight(24)
self.__layout = QHBoxLayout(self)
self.__layout.setContentsMargins(0, 0, 0, 0)
# Create info icon
self.__infoIcon = QLabel(self)
self.__infoIcon.setPixmap(getPixmap('cfunknown.png'))
self.__layout.addWidget(self.__infoIcon)
self.__warningsIcon = QLabel(self)
self.__warningsIcon.setPixmap(getPixmap('cfwarning.png'))
self.__layout.addWidget(self.__warningsIcon)
self.clearWarnings()
labelStylesheet = 'QLabel {' + getLabelStyle(self.__infoIcon) + '}'
# Create the path label
self.__pathLabel = QLabel(self)
self.__pathLabel.setStyleSheet(labelStylesheet)
self.__pathLabel.setTextFormat(Qt.PlainText)
self.__pathLabel.setAlignment(Qt.AlignLeft)
self.__pathLabel.setWordWrap(False)
self.__pathLabel.setTextInteractionFlags(Qt.NoTextInteraction)
self.__pathLabel.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.__layout.addWidget(self.__pathLabel)
self.__spacer = QWidget()
self.__spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.__spacer.setMinimumWidth(0)
self.__layout.addWidget(self.__spacer)
# Create the selection label
self.__selectionLabel = QLabel(self)
self.__selectionLabel.setStyleSheet(labelStylesheet)
self.__selectionLabel.setTextFormat(Qt.PlainText)
self.__selectionLabel.setAlignment(Qt.AlignCenter)
self.__selectionLabel.setWordWrap(False)
self.__selectionLabel.setTextInteractionFlags(Qt.NoTextInteraction)
self.__selectionLabel.setSizePolicy(QSizePolicy.Fixed,
QSizePolicy.Fixed)
self.__selectionLabel.setMinimumWidth(40)
self.__layout.addWidget(self.__selectionLabel)
self.setSelectionLabel(0, None)
def clearWarnings(self):
"""Clears the warnings"""
self.__warningsIcon.setVisible(False)
self.__warningsIcon.setToolTip("")
def setWarnings(self, warnings):
"""Sets the warnings"""
self.__warningsIcon.setToolTip('Control flow parser warnings:\n' +
'\n'.join(warnings))
self.__warningsIcon.setVisible(True)
def clearErrors(self):
"""Clears all the errors"""
self.__infoIcon.setToolTip('')
def setErrors(self, errors):
"""Sets the errors"""
self.__infoIcon.setToolTip('Control flow parser errors:\n' +
'\n'.join(errors))
def updateInfoIcon(self, state):
"""Updates the information icon"""
if state == self.__currentIconState:
return
if state == self.STATE_OK_UTD:
self.__infoIcon.setPixmap(getPixmap('cfokutd.png'))
self.__infoIcon.setToolTip("Control flow is up to date")
self.__currentIconState = self.STATE_OK_UTD
elif state == self.STATE_OK_CHN:
self.__infoIcon.setPixmap(getPixmap('cfokchn.png'))
self.__infoIcon.setToolTip("Control flow is not up to date; "
"will be updated on idle")
self.__currentIconState = self.STATE_OK_CHN
elif state == self.STATE_BROKEN_UTD:
self.__infoIcon.setPixmap(getPixmap('cfbrokenutd.png'))
self.__infoIcon.setToolTip("Control flow might be invalid "
"due to invalid python code")
self.__currentIconState = self.STATE_BROKEN_UTD
elif state == self.STATE_BROKEN_CHN:
self.__infoIcon.setPixmap(getPixmap('cfbrokenchn.png'))
self.__infoIcon.setToolTip("Control flow might be invalid; "
"will be updated on idle")
self.__currentIconState = self.STATE_BROKEN_CHN
else:
# STATE_UNKNOWN
self.__infoIcon.setPixmap(getPixmap('cfunknown.png'))
self.__infoIcon.setToolTip("Control flow state is unknown")
self.__currentIconState = self.STATE_UNKNOWN
def getCurrentState(self):
"""Provides the current state"""
return self.__currentIconState
def setPath(self, txt):
"""Sets the path label content"""
self.__pathLabel.setText(txt)
def setPathVisible(self, switchOn):
"""Sets the path visible"""
self.__pathLabel.setVisible(switchOn)
self.__spacer.setVisible(not switchOn)
def setSelectionLabel(self, text, tooltip):
"""Sets selection label"""
self.__selectionLabel.setText(str(text))
if tooltip:
self.__selectionLabel.setToolTip("Selected items:\n" +
str(tooltip))
else:
self.__selectionLabel.setToolTip("Number of selected items")
def resizeEvent(self, event):
"""Editor has resized"""
QFrame.resizeEvent(self, event)
def __createLayout(self, action, title, files):
"""Creates the dialog layout"""
self.resize(400, 300)
self.setSizeGripEnabled(True)
# Top level layout
layout = QVBoxLayout(self)
# Pixmap and the message
topLayout = QHBoxLayout()
pixmap = QLabel()
pixmap.setPixmap(getPixmap('warning.png'))
topLayout.addWidget(pixmap)
hSpacer = QWidget()
hSpacer.setFixedSize(15, 15)
topLayout.addWidget(hSpacer)
message = QLabel("All the project files must be "
"saved before start debugging")
message.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
message.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
message.setWordWrap(True)
topLayout.addWidget(message)
layout.addLayout(topLayout)
vSpacer = QWidget()
vSpacer.setFixedSize(15, 15)
layout.addWidget(vSpacer)
layout.addWidget(QLabel(title + ":"))
filesList = QTreeWidget()
filesList.setRootIsDecorated(False)
filesList.setAlternatingRowColors(True)
filesList.setUniformRowHeights(True)
filesList.setItemsExpandable(False)
filesList.setItemDelegate(NoOutlineHeightDelegate(4))
filesList.setSelectionMode(QAbstractItemView.NoSelection)
filesList.setHeaderHidden(True)
for item in files:
fileName = item[0]
fileItem = QTreeWidgetItem([fileName])
fileType, icon, _ = getFileProperties(fileName)
fileItem.setIcon(0, icon)
if isPythonMime(fileType):
info = GlobalData().briefModinfoCache.get(fileName)
fileItem.setToolTip(
0, info.docstring.text if info.docstring else '')
filesList.addTopLevelItem(fileItem)
layout.addWidget(filesList)
# Buttons at the bottom
buttonBox = QDialogButtonBox()
buttonBox.setOrientation(Qt.Horizontal)
buttonBox.setStandardButtons(QDialogButtonBox.Cancel)
continueButton = buttonBox.addButton(action,
QDialogButtonBox.ActionRole)
continueButton.setDefault(True)
layout.addWidget(buttonBox)
continueButton.clicked.connect(self.accept)
buttonBox.rejected.connect(self.close)
continueButton.setFocus()
class SearchResultsViewer(QWidget):
"""Search results viewer tab widget"""
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.__results = QStackedWidget(self)
self.__bufferChangeConnected = False
# Prepare members for reuse
self.__noneLabel = QLabel("\nNo results available")
self.__noneLabel.setFrameShape(QFrame.StyledPanel)
self.__noneLabel.setAlignment(Qt.AlignHCenter)
self.__headerFont = self.__noneLabel.font()
self.__headerFont.setPointSize(self.__headerFont.pointSize() + 4)
self.__noneLabel.setFont(self.__headerFont)
self.__noneLabel.setAutoFillBackground(True)
noneLabelPalette = self.__noneLabel.palette()
noneLabelPalette.setColor(QPalette.Background,
GlobalData().skin['nolexerPaper'])
self.__noneLabel.setPalette(noneLabelPalette)
self.__createLayout(parent)
self.__updateButtonsStatus()
GlobalData().project.sigProjectChanged.connect(self.__onProjectChanged)
def __createLayout(self, parent):
"""Creates the toolbar and layout"""
del parent # unused argument
# Buttons etc.
self.clearButton = QAction(getIcon('trash.png'),
'Delete current results', self)
self.clearButton.triggered.connect(self.__clear)
self.prevButton = QAction(getIcon('1leftarrow.png'),
'Previous results', self)
self.prevButton.triggered.connect(self.__previous)
self.nextButton = QAction(getIcon('1rightarrow.png'),
'Next results', self)
self.nextButton.triggered.connect(self.__next)
self.doAgainButton = QAction(getIcon('searchagain.png'),
'Do again', self)
self.doAgainButton.triggered.connect(self.__doAgain)
self.removeItemButton = QAction(getIcon('delitem.png'),
'Remove currently selected item (Del)',
self)
self.removeItemButton.triggered.connect(self.__removeItem)
# The toolbar
self.toolbar = QToolBar(self)
self.toolbar.setOrientation(Qt.Vertical)
self.toolbar.setMovable(False)
self.toolbar.setAllowedAreas(Qt.RightToolBarArea)
self.toolbar.setIconSize(QSize(16, 16))
self.toolbar.setFixedWidth(28)
self.toolbar.setContentsMargins(0, 0, 0, 0)
self.toolbar.addAction(self.prevButton)
self.toolbar.addAction(self.nextButton)
self.toolbar.addAction(self.doAgainButton)
self.toolbar.addWidget(ToolBarExpandingSpacer(self.toolbar))
self.toolbar.addAction(self.removeItemButton)
self.toolbar.addAction(self.clearButton)
self.__hLayout = QHBoxLayout()
self.__hLayout.setContentsMargins(0, 0, 0, 0)
self.__hLayout.setSpacing(0)
self.__hLayout.addWidget(self.toolbar)
self.__hLayout.addWidget(self.__noneLabel)
self.__hLayout.addWidget(self.__results)
self.__results.hide()
self.setLayout(self.__hLayout)
def __isReportShown(self):
"""True is any of the reports is shown"""
return self.__results.count() > 0
def getResultsViewer(self):
"""Provides a reference to the results tree"""
return self.__results
def __updateButtonsStatus(self):
"""Updates the buttons status"""
if self.__isReportShown():
index = self.__results.currentIndex()
widget = self.__results.currentWidget()
self.prevButton.setEnabled(index > 0)
self.nextButton.setEnabled(index < self.__results.count() - 1)
self.doAgainButton.setEnabled(widget.canDoAgain())
self.removeItemButton.setEnabled(widget.selectedItem is not None)
self.clearButton.setEnabled(True)
else:
self.prevButton.setEnabled(False)
self.nextButton.setEnabled(False)
self.doAgainButton.setEnabled(False)
self.removeItemButton.setEnabled(False)
self.clearButton.setEnabled(False)
def __updateIndicators(self):
"""Updates all the indicators"""
total = self.__results.count()
for index in range(total):
self.__results.widget(index).updateIndicator(index + 1, total)
def setFocus(self):
"""Overridden setFocus"""
self.__hLayout.setFocus()
def __onProjectChanged(self, what):
"""Triggered when a project is changed"""
if what == CodimensionProject.CompleteProject:
self.__saveProjectResults()
self.__populateForProject()
def __connectBufferChange(self):
"""Connects the sigBufferChange"""
if not self.__bufferChangeConnected:
self.__bufferChangeConnected = True
mainWindow = GlobalData().mainWindow
editorsManager = mainWindow.editorsManagerWidget.editorsManager
editorsManager.sigBufferModified.connect(self.onBufferModified)
def __disconnectBufferChange(self):
"""Disconnects the sigBufferModified signal"""
if self.__bufferChangeConnected:
self.__bufferChangeConnected = False
mainWindow = GlobalData().mainWindow
editorsManager = mainWindow.editorsManagerWidget.editorsManager
editorsManager.sigBufferModified.disconnect(self.onBufferModified)
def onBufferModified(self, fileName, uuid):
"""Triggered when a buffer is modified"""
for index in range(self.__results.count()):
self.__results.widget(index).resultsTree.onBufferModified(
fileName, uuid)
def __previous(self):
"""Switch to the previous results"""
if self.__isReportShown():
index = self.__results.currentIndex()
if index > 0:
self.__results.setCurrentIndex(index - 1)
self.__updateButtonsStatus()
def __next(self):
"""Switch to the next results"""
if self.__isReportShown():
index = self.__results.currentIndex()
if index < self.__results.count() - 1:
self.__results.setCurrentIndex(index + 1)
self.__updateButtonsStatus()
def keyPressEvent(self, event):
"""Del key processing"""
if event.key() == Qt.Key_Delete:
event.accept()
self.__removeItem()
else:
QWidget.keyPressEvent(self, event)
def __removeItem(self):
"""Removes one entry of the search"""
widget = self.__results.currentWidget()
if widget.selectedItem is None:
return
widget.removeSelectedItem()
if widget.resultsTree.topLevelItemCount() == 0:
# The last result, need to remove the search result
self.__clear()
else:
self.__updateButtonsStatus()
def __clear(self):
"""Clears the content of the vertical layout"""
if not self.__isReportShown():
return
index = self.__results.currentIndex()
widget = self.__results.currentWidget()
widget.clear()
if self.__results.count() == 1:
self.__results.hide()
self.__noneLabel.show()
self.__disconnectBufferChange()
self.__results.removeWidget(widget)
widget.deleteLater()
if self.__results.count() > 0:
if index >= self.__results.count():
index -= 1
self.__results.setCurrentIndex(index)
self.__updateButtonsStatus()
self.__updateIndicators()
def __doAgain(self):
"""Performs the action once again"""
if self.__isReportShown():
self.__results.currentWidget().doAgain(self)
def showReport(self, providerId, results, parameters, searchId=None):
"""Shows the find in files results"""
# Memorize the screen width
searchTooltip.setScreenWidth(
GlobalData().application.desktop().screenGeometry().width())
if searchId is None:
resultWidget = ResultsViewerWidget(providerId, results,
parameters,
str(uuid1()), self)
index = self.__results.addWidget(resultWidget)
else:
# Find the widget with this searchId
found = False
for index in range(self.__results.count()):
if self.__results.widget(index).searchId == searchId:
found = True
break
if not found:
# add as a new one
resultWidget = ResultsViewerWidget(providerId, results,
parameters,
str(uuid1()), self)
index = self.__results.addWidget(resultWidget)
else:
# Repopulate it
widget = self.__results.widget(index)
widget.populate(results)
self.__results.setCurrentIndex(index)
# Show the complete information
self.__noneLabel.hide()
self.__results.show()
self.__updateButtonsStatus()
self.__updateIndicators()
self.__connectBufferChange()
def __populateForProject(self):
"""Load the project saved search results"""
def __saveProjectResults(self):
"""Serialize to the disk the search results"""
class PylintResultViewer(QWidget):
"""Pylint results viewer"""
def __init__(self, ide, pluginHomeDir, parent=None):
QWidget.__init__(self, parent)
self.__results = None
self.__ide = ide
self.__pluginHomeDir = pluginHomeDir
self.__noneLabel = QLabel("\nNo results available")
self.__noneLabel.setFrameShape(QFrame.StyledPanel)
self.__noneLabel.setAlignment(Qt.AlignHCenter)
font = self.__noneLabel.font()
font.setPointSize(font.pointSize() + 4)
self.__noneLabel.setFont(font)
self.__noneLabel.setAutoFillBackground(True)
noneLabelPalette = self.__noneLabel.palette()
noneLabelPalette.setColor(QPalette.Background,
GlobalData().skin['nolexerPaper'])
self.__noneLabel.setPalette(noneLabelPalette)
self.__createLayout(self.__pluginHomeDir)
def __createLayout(self, pluginHomeDir):
"""Creates the layout"""
self.clearButton = QAction(getIcon('trash.png'), 'Clear', self)
self.clearButton.triggered.connect(self.clear)
self.outputButton = QAction(QIcon(pluginHomeDir + 'output.png'),
'Show pylint raw stdout and stderr', self)
self.outputButton.triggered.connect(self.__showOutput)
self.toolbar = QToolBar(self)
self.toolbar.setOrientation(Qt.Vertical)
self.toolbar.setMovable(False)
self.toolbar.setAllowedAreas(Qt.RightToolBarArea)
self.toolbar.setIconSize(QSize(16, 16))
self.toolbar.setFixedWidth(28)
self.toolbar.setContentsMargins(0, 0, 0, 0)
self.toolbar.addAction(self.outputButton)
self.toolbar.addWidget(ToolBarExpandingSpacer(self.toolbar))
self.toolbar.addAction(self.clearButton)
self.__resultsTree = QTreeWidget(self)
self.__resultsTree.setAlternatingRowColors(True)
self.__resultsTree.setRootIsDecorated(True)
self.__resultsTree.setItemsExpandable(True)
self.__resultsTree.setUniformRowHeights(True)
self.__resultsTree.setItemDelegate(NoOutlineHeightDelegate(4))
headerLabels = ['Message type / line', 'id', 'Message']
self.__resultsTree.setHeaderLabels(headerLabels)
self.__resultsTree.itemActivated.connect(self.__resultActivated)
self.__fileLabel = HeaderFitPathLabel(None, self)
self.__fileLabel.setAlignment(Qt.AlignLeft)
self.__fileLabel.setMinimumWidth(50)
self.__fileLabel.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Fixed)
self.__fileLabel.doubleClicked.connect(self.onPathLabelDoubleClick)
self.__fileLabel.setContextMenuPolicy(Qt.CustomContextMenu)
self.__fileLabel.customContextMenuRequested.connect(
self.showPathLabelContextMenu)
self.__rateLabel = HeaderLabel()
self.__rateLabel.setToolTip('pylint analysis rate out of 10 '
'(previous run if there was one)')
self.__timestampLabel = HeaderLabel()
self.__timestampLabel.setToolTip('pylint analysis timestamp')
self.__labelLayout = QHBoxLayout()
self.__labelLayout.setSpacing(4)
self.__labelLayout.addWidget(self.__fileLabel)
self.__labelLayout.addWidget(self.__rateLabel)
self.__labelLayout.addWidget(self.__timestampLabel)
self.__vLayout = QVBoxLayout()
self.__vLayout.setSpacing(4)
self.__vLayout.addLayout(self.__labelLayout)
self.__vLayout.addWidget(self.__resultsTree)
self.__hLayout = QHBoxLayout()
self.__hLayout.setContentsMargins(0, 0, 0, 0)
self.__hLayout.setSpacing(0)
self.__hLayout.addWidget(self.toolbar)
self.__hLayout.addWidget(self.__noneLabel)
self.__hLayout.addLayout(self.__vLayout)
self.setLayout(self.__hLayout)
self.__updateButtons()
def __updateButtons(self):
"""Updates the toolbar buttons approprietly"""
self.clearButton.setEnabled(self.__results is not None)
if self.__results is not None:
stdout = self.__results.get('StdOut', None)
stderr = self.__results.get('StdErr', None)
self.outputButton.setEnabled(stdout is not None or
stderr is not None)
else:
self.outputButton.setEnabled(False)
def showResults(self, results):
"""Populates the analysis results"""
self.clear()
self.__noneLabel.setVisible(False)
self.__fileLabel.setVisible(True)
self.__rateLabel.setVisible(True)
self.__timestampLabel.setVisible(True)
self.__resultsTree.setVisible(True)
self.__results = results
self.__updateButtons()
tooltip = ' '.join(['pylint results for',
os.path.basename(results['FileName']),
'at',
results['Timestamp']])
self.__ide.sideBars['bottom'].setTabToolTip('pylint', tooltip)
self.__fileLabel.setPath(results['FileName'])
if 'Rate' in results:
text = str(results['Rate'])
if 'PreviousRunRate' in results:
text += ' (' + str(results['PreviousRunRate']) + ')'
self.__rateLabel.setText(' ' + text + ' ')
else:
self.__rateLabel.setVisible(False)
self.__timestampLabel.setText(results['Timestamp'])
totalMessages = 0
totalMessages += self.__populateMessages('Errors')
totalMessages += self.__populateMessages('Warnings')
totalMessages += self.__populateMessages('Refactoring')
totalMessages += self.__populateMessages('Cosmetics')
# Update the header with the total number of matches
headerLabels = ['Message type / line', 'id',
'Message (total messages: ' + str(totalMessages) + ')']
self.__resultsTree.setHeaderLabels(headerLabels)
# Resizing
self.__resultsTree.header().resizeSections(
QHeaderView.ResizeToContents)
def __populateMessages(self, title):
"""Populates the analysis messages"""
count = len(self.__results[title[0]])
if count > 0:
suffix = '' if count == 1 else 's'
messageTypeItem = MessageTypeTableItem(
[title, '', '(' + str(count) + ' message' + suffix + ')'])
self.__resultsTree.addTopLevelItem(messageTypeItem)
for item in self.__results[title[0]]:
columns = [str(item[1]), item[3], item[2]]
messageItem = MessageTableItem(columns)
messageTypeItem.addChild(messageItem)
messageTypeItem.setExpanded(True)
return count
def clear(self):
"""Clears the results view"""
self.__results = None
self.__updateButtons()
tooltip = 'No results available'
self.__ide.sideBars['bottom'].setTabToolTip('pylint', tooltip)
self.__noneLabel.setVisible(True)
self.__fileLabel.setVisible(False)
self.__rateLabel.setVisible(False)
self.__timestampLabel.setVisible(False)
self.__resultsTree.setVisible(False)
self.__resultsTree.clear()
def __resultActivated(self, item, column):
"""Handles the double click (or Enter) on a message"""
del column # unused argument
if self.__results:
if isinstance(item, MessageTableItem):
fileName = self.__results['FileName']
lineNumber = int(item.data(0, Qt.DisplayRole))
self.__ide.mainWindow.openFile(fileName, lineNumber)
def __showOutput(self):
"""Shows the analysis stdout and stderr"""
if self.__results is None:
return
# Show a separate dialog
PylintStdoutStderrViewer(self.__ide.mainWindow,
self.__results).exec_()
def onPathLabelDoubleClick(self):
"""Double click on the path label"""
txt = self.__getPathLabelFilePath()
if txt.lower():
QApplication.clipboard().setText(txt)
def __getPathLabelFilePath(self):
"""Provides undecorated path label content"""
txt = str(self.__fileLabel.getPath())
if txt.startswith('File: '):
return txt.replace('File: ', '')
return txt
def showPathLabelContextMenu(self, pos):
"""Triggered when a context menu is requested for the path label"""
contextMenu = QMenu(self)
contextMenu.addAction(getIcon('copymenu.png'),
'Copy full path to clipboard (double click)',
self.onPathLabelDoubleClick)
contextMenu.addSeparator()
contextMenu.addAction(getIcon(''), 'Copy directory path to clipboard',
self.onCopyDirToClipboard)
contextMenu.addAction(getIcon(''), 'Copy file name to clipboard',
self.onCopyFileNameToClipboard)
contextMenu.popup(self.__fileLabel.mapToGlobal(pos))
def onCopyDirToClipboard(self):
"""Copies the dir path of the current file into the clipboard"""
txt = self.__getPathLabelFilePath()
if txt.lower():
try:
QApplication.clipboard().setText(os.path.dirname(txt) +
os.path.sep)
except:
pass
def onCopyFileNameToClipboard(self):
"""Copies the file name of the current file into the clipboard"""
txt = self.__getPathLabelFilePath()
if txt.lower():
try:
QApplication.clipboard().setText(os.path.basename(txt))
except:
pass
