class CFSceneContextMenuMixin: """Encapsulates the context menu handling""" def __init__(self): self.menu = None self.individualMenus = {} # Scene menu preparation self.sceneMenu = QMenu() self.sceneMenu.addAction(getIcon('filesvg.png'), 'Save as SVG...', self.parent().onSaveAsSVG) self.sceneMenu.addAction(getIcon('filepdf.png'), 'Save as PDF...', self.parent().onSaveAsPDF) self.sceneMenu.addAction(getIcon('filepixmap.png'), 'Save as PNG...', self.parent().onSaveAsPNG) self.sceneMenu.addSeparator() self.sceneMenu.addAction(getIcon('copymenu.png'), 'Copy image to clipboard', self.parent().copyToClipboard) # Common menu for all the individually selected items self.commonMenu = QMenu() self.__ccSubmenuAction = self.commonMenu.addMenu( self.__initCustomColorsContextMenu()) self.__rtSubmenuAction = self.commonMenu.addMenu( self.__initReplaceTextContextMenu()) self.__docSubmenuAction = self.commonMenu.addMenu( self.__initDocContextMenu()) self.__groupAction = self.commonMenu.addAction( getIcon("cfgroup.png"), "Group...", self.onGroup) #self.commonMenu.addSeparator() #self.__cutAction = self.commonMenu.addAction( # getIcon("cutmenu.png"), "Cut (specific for graphics pane)", # self.onCut) #self.__copyAction = self.commonMenu.addAction( # getIcon("copymenu.png"), "Copy (specific for graphics pane)", # self.onCopy) #self.commonMenu.addSeparator() #self.commonMenu.addAction( # getIcon("trash.png"), "Delete", self.onDelete) # Individual items specific menu: begin ifContextMenu = QMenu() ifContextMenu.addAction( getIcon("switchbranches.png"), "Switch branch layout", self.onSwitchIfBranch) self.individualMenus[IfCell] = ifContextMenu self.individualMenus[OpenedGroupBegin] = self.__initOpenGroupContextMenu() self.individualMenus[CollapsedGroup] = self.__initCloseGroupContextMenu() self.individualMenus[EmptyGroup] = self.__initEmptyGroupContextMenu() # Individual items specific menu: end # Menu for a group of selected items self.groupMenu = QMenu() def __initOpenGroupContextMenu(self): """Creates the open group context menu""" ogMenu = QMenu() ogMenu.addAction(getIcon("collapse.png"), "Collapse", self.onGroupCollapse) ogMenu.addAction(getIcon("replacetitle.png"), "Edit title...", self.onGroupEditTitle) ogMenu.addAction(getIcon("ungroup.png"), "Ungroup", self.onGroupUngroup) return ogMenu def __initCloseGroupContextMenu(self): """Creates the closed group context menu""" cgMenu = QMenu() cgMenu.addAction(getIcon("expand.png"), "Expand", self.onGroupExpand) cgMenu.addAction(getIcon("replacetitle.png"), "Edit title...", self.onGroupEditTitle) cgMenu.addAction(getIcon("ungroup.png"), "Ungroup", self.onGroupUngroup) return cgMenu def __initEmptyGroupContextMenu(self): """Creates the empty group context menu""" egMenu = QMenu() egMenu.addAction(getIcon("replacetitle.png"), "Edit title...", self.onGroupEditTitle) egMenu.addAction(getIcon("ungroup.png"), "Ungroup", self.onGroupUngroup) return egMenu def __initCustomColorsContextMenu(self): """Create the custom colors submenu""" self.__customColorsSubmenu = QMenu('Custom colors') self.__customColorsSubmenu.setIcon(getIcon('customcolorsmenu.png')) self.__ccAction = self.__customColorsSubmenu.addAction( getIcon("customcolors.png"), "Custom colors...", self.onCustomColors) self.__customColorsSubmenu.addSeparator() self.__removeCCAction = self.__customColorsSubmenu.addAction( getIcon('trash.png'), 'Remove custom colors', self.onRemoveCustomColors) return self.__customColorsSubmenu def __initReplaceTextContextMenu(self): """Create the Replace text submenu""" self.__replaceTextSubmenu = QMenu('Replace text') self.__replaceTextSubmenu.setIcon(getIcon('replacetextmenu.png')) self.__rtAction = self.__replaceTextSubmenu.addAction( getIcon("replacetitle.png"), "Replace text...", self.onReplaceText) self.__replaceTextSubmenu.addSeparator() self.__removeRTAction = self.__replaceTextSubmenu.addAction( getIcon('trash.png'), 'Remove replacement text', self.onRemoveReplacementText) return self.__replaceTextSubmenu def __initDocContextMenu(self): """Create the Documentation submenu""" self.__docSubmenu = QMenu('Documentation') self.__docSubmenu.setIcon(getIcon('markdown.png')) self.__editDocAction = self.__docSubmenu.addAction( getIcon('replacetitle.png'), 'Add/edit doc link/anchor...', self.onEditDoc) self.__autoDocActon = self.__docSubmenu.addAction( getIcon('createdoc.png'), 'Create doc file, add link and open for editing', self.onAutoAddDoc) self.__docSubmenu.addSeparator() self.__removeDocAction = self.__docSubmenu.addAction( getIcon('trash.png'), 'Remove doc link/anchor', self.onRemoveDoc) return self.__docSubmenu def onContextMenu(self, event): """Triggered when a context menu should be shown""" selectedItems = self.selectedItems() selectionCount = len(selectedItems) if selectionCount == 0: self.sceneMenu.popup(event.screenPos()) return if selectionCount == 1: self.__buildIndividualMenu(selectedItems[0]) else: self.__buildGroupMenu(selectedItems) self.menu.popup(event.screenPos()) def __buildIndividualMenu(self, item): """Builds a context menu for the given item""" self.menu = QMenu() if type(item) in self.individualMenus: individualPart = self.individualMenus[type(item)] self.menu.addActions(individualPart.actions()) self.menu.addSeparator() self.menu.addActions(self.commonMenu.actions()) # Note: if certain items need to be disabled then it should be done # here self.__disableMenuItems() def __buildGroupMenu(self, items): """Builds a context menu for the group of items""" self.menu = QMenu() if type(items[0]) in self.individualMenus: if self.areSelectedOfTypes([[items[0].kind, items[0].subKind]]): individualPart = self.individualMenus[type(items[0])] self.menu.addActions(individualPart.actions()) self.menu.addSeparator() self.menu.addActions(self.commonMenu.actions()) if not self.groupMenu.isEmpty(): self.menu.addSeparator() self.menu.addActions(self.groupMenu.actions()) # Note: if certain items need to be disabled then it should be done # here self.__disableMenuItems() def __disableMenuItems(self): """Disables the common menu items as needed""" totalComments = self.countComments() hasComment = totalComments > 0 hasDocstring = self.isDocstringInSelection() hasMinimizedExcepts = self.isInSelected([(CellElement.EXCEPT_MINIMIZED, None)]) # Doc links are considered comments as well totalDocLinks = self.countInSelected([(CellElement.INDEPENDENT_DOC, None), (CellElement.LEADING_DOC, None), (CellElement.ABOVE_DOC, None)]) totalNonDocComments = totalComments - totalDocLinks totalGroups = sum(self.countGroups()) count = len(self.selectedItems()) totalCCGroups = sum(self.countGroupsWithCustomColors()) totalCCDocs = self.countDocWithCustomColors() self.__ccAction.setEnabled(totalNonDocComments == 0 and not hasMinimizedExcepts) self.__removeCCAction.setEnabled( self.countItemsWithCML(CMLcc) + totalCCGroups + totalCCDocs == count) self.__customColorsSubmenu.setEnabled(self.__ccAction.isEnabled() or self.__removeCCAction.isEnabled()) self.__rtAction.setEnabled(not hasComment and not hasDocstring and not hasMinimizedExcepts and totalDocLinks == 0 and totalGroups == 0) self.__removeRTAction.setEnabled( self.countItemsWithCML(CMLrt) == count) self.__replaceTextSubmenu.setEnabled(self.__rtAction.isEnabled() or self.__removeRTAction.isEnabled()) self.__groupAction.setEnabled(self.__canBeGrouped()) itemsWithDocCML = self.countItemsWithCML(CMLdoc) self.__removeDocAction.setEnabled(totalDocLinks + itemsWithDocCML == count) if count != 1 or totalNonDocComments != 0 or hasDocstring or totalGroups != 0: self.__editDocAction.setEnabled(False) self.__autoDocActon.setEnabled(False) else: self.__editDocAction.setEnabled(True) fileName = None editor = self.selectedItems()[0].getEditor() if editor: fileName = editor._parent.getFileName() self.__autoDocActon.setEnabled( fileName and totalDocLinks + itemsWithDocCML == 0) self.__docSubmenu.setEnabled(self.__removeDocAction.isEnabled() or self.__editDocAction.isEnabled() or self.__autoDocActon.isEnabled()) #self.__cutAction.setEnabled(count == 1) #self.__copyAction.setEnabled(count == 1) def __actionPrerequisites(self): """True if an editor related action can be done""" selectedItems = self.selectedItems() if not selectedItems: return False editor = selectedItems[0].getEditor() if editor is None: return False return True def onSwitchIfBranch(self): """If primitive should switch the branches""" if not self.__actionPrerequisites(): return # Memorize the current selection selection = self.serializeSelection() # The selected items need to be sorted in the reverse line no oreder editor = self.selectedItems()[0].getEditor() with editor: for item in self.sortSelectedReverse(): if item.kind == CellElement.IF: cmlComment = CMLVersion.find(item.ref.leadingCMLComments, CMLsw) if cmlComment is None: # Did not exist, so needs to be generated line = CMLsw.generate(item.ref.body.beginPos) lineNo = item.getFirstLine() editor.insertLines(line, lineNo) else: # Existed, so it just needs to be deleted cmlComment.removeFromText(editor) QApplication.processEvents() self.parent().redrawNow() self.restoreSelectionByID(selection) def onCustomColors(self): """Custom background and foreground colors""" if not self.__actionPrerequisites(): return # Memorize the current selection selection = self.serializeSelection() bgcolor, fgcolor, bordercolor = self.selectedItems()[0].getColors() hasDocstring = self.isDocstringInSelection() dlg = CustomColorsDialog(bgcolor, fgcolor, None if hasDocstring else bordercolor, self.parent()) if dlg.exec_(): bgcolor = dlg.backgroundColor() fgcolor = dlg.foregroundColor() bordercolor = dlg.borderColor() editor = self.selectedItems()[0].getEditor() with editor: # Add colors is done via delete/insert for the Doc and group # items. So it is safer to do first because the cc comment may be # in a set of selected which is inserted before the doc cml and # thus breaks the line numbering for item in self.selectedItems(): if item.isCMLDoc(): # The doc always exists so just add/change the colors item.cmlRef.updateCustomColors(editor, bgcolor, fgcolor, bordercolor) continue if item.isGroupItem(): # The group always exists so just add/change the colors item.groupBeginCMLRef.updateCustomColors(editor, bgcolor, fgcolor, bordercolor) for item in self.sortSelectedReverse(): if item.isCMLDoc() or item.isGroupItem(): continue if item.isDocstring(): cmlComment = CMLVersion.find( item.ref.docstring.leadingCMLComments, CMLcc) else: cmlComment = CMLVersion.find( item.ref.leadingCMLComments, CMLcc) if cmlComment is not None: # Existed, so remove the old one first lineNo = cmlComment.ref.beginLine cmlComment.removeFromText(editor) else: lineNo = item.getFirstLine() pos = item.ref.body.beginPos if item.isDocstring(): pos = item.ref.docstring.beginPos line = CMLcc.generate(bgcolor, fgcolor, bordercolor, pos) editor.insertLines(line, lineNo) QApplication.processEvents() self.parent().redrawNow() self.restoreSelectionByID(selection) def onReplaceText(self): """Replace the code with a title""" if not self.__actionPrerequisites(): return # Memorize the current selection selection = self.serializeSelection() dlg = ReplaceTextDialog('Replace text', 'Item caption:', self.parent()) # If it was one item selection and there was a previous text then # set it for editing if len(self.selectedItems()) == 1: cmlComment = CMLVersion.find( self.selectedItems()[0].ref.leadingCMLComments, CMLrt) if cmlComment is not None: dlg.setText(cmlComment.getText()) if dlg.exec_(): replacementText = dlg.text() editor = self.selectedItems()[0].getEditor() with editor: for item in self.sortSelectedReverse(): cmlComment = CMLVersion.find( item.ref.leadingCMLComments, CMLrt) if cmlComment is not None: # Existed, so remove the old one first lineNo = cmlComment.ref.beginLine cmlComment.removeFromText(editor) else: lineNo = item.getFirstLine() line = CMLrt.generate(replacementText, item.ref.body.beginPos) editor.insertLines(line, lineNo) QApplication.processEvents() self.parent().redrawNow() self.restoreSelectionByID(selection) def onGroupCollapse(self): """Collapses the selected group""" if not self.__actionPrerequisites(): return # The selected items need to be sorted in the reverse line no oreder editor = self.selectedItems()[0].getEditor() with editor: for item in self.sortSelectedReverse(): if item.kind == CellElement.OPENED_GROUP_BEGIN: fileName = editor._parent.getFileName() if not fileName: fileName = editor._parent.getShortName() addCollapsedGroup(fileName, item.getGroupId()) QApplication.processEvents() self.parent().redrawNow() def onGroupExpand(self): """Expands the selected group""" if not self.__actionPrerequisites(): return # The selected items need to be sorted in the reverse line no oreder editor = self.selectedItems()[0].getEditor() with editor: for item in self.sortSelectedReverse(): if item.kind == CellElement.COLLAPSED_GROUP: fileName = editor._parent.getFileName() if not fileName: fileName = editor._parent.getShortName() removeCollapsedGroup(fileName, item.getGroupId()) QApplication.processEvents() self.parent().redrawNow() def onGroupEditTitle(self): """Edit (or view) the group title""" if not self.__actionPrerequisites(): return # Memorize the current selection selection = self.serializeSelection() dlg = ReplaceTextDialog('Group title', 'Group title:', self.parent()) # If it was one item selection and there was a previous text then # set it for editing if len(self.selectedItems()) == 1: title = self.selectedItems()[0].getTitle() if title: dlg.setText(title) if dlg.exec_(): newTitle = dlg.text() editor = self.selectedItems()[0].getEditor() with editor: for item in self.sortSelectedReverse(): item.groupBeginCMLRef.updateTitle(editor, newTitle) QApplication.processEvents() self.parent().redrawNow() self.restoreSelectionByID(selection) def onGroupUngroup(self): """Ungroups the items""" if not self.__actionPrerequisites(): return # Memorize the current selection selection = self.serializeSelection() # The selected items need to be sorted in the reverse line no oreder editor = self.selectedItems()[0].getEditor() with editor: for item in self.sortSelectedReverse(): item.groupEndCMLRef.removeFromText(editor) item.groupBeginCMLRef.removeFromText(editor) QApplication.processEvents() self.parent().redrawNow() self.restoreSelectionByTooltip(selection) def onDelete(self): """Delete the item""" print("Delete") def onGroup(self): """Groups items into a single one""" dlg = ReplaceTextDialog('Group title', 'Group title:', self.parent()) if dlg.exec_(): groupTitle = dlg.text() selected = self.__extendSelectionForGrouping() selected = self.sortSelected(selected) editor = selected[0].getEditor() firstLine, lastLine, pos = self.__getLineRange(selected) groupid = self.parent().generateNewGroupId() beginComment = CMLgb.generate(groupid, groupTitle, None, None, None, pos) endComment = CMLge.generate(groupid, pos) with editor: editor.insertLines(endComment, lastLine + 1) editor.insertLines(beginComment, firstLine) # Redraw the group collapsed fileName = editor._parent.getFileName() if not fileName: fileName = editor._parent.getShortName() addCollapsedGroup(fileName, groupid) QApplication.processEvents() self.parent().redrawNow() def onCopy(self): """Copying...""" selectedItems = self.selectedItems() if selectedItems: if len(selectedItems) > 1: print('Copying multiple items has not been implemented yet') return selectedItems[0].copyToClipboard() def onCut(self): """Cutting...""" print("Cut") def onRemoveCustomColors(self): """Removing the previously set custom colors""" if not self.__actionPrerequisites(): return # Memorize the current selection selection = self.serializeSelection() editor = self.selectedItems()[0].getEditor() with editor: # Remove colors is done via delete/insert for the Doc and group # items. So it is safer to do first because the cc comment may be # in a set of selected which is inserted before the doc cml and # thus breaks the line numbering for item in self.selectedItems(): # The doc always exists if item.isCMLDoc(): item.cmlRef.removeCustomColors(editor) continue # The group always exists if item.isGroupItem(): item.groupBeginCMLRef.removeCustomColors(editor) # Now handle the rest of items for item in self.sortSelectedReverse(): if item.isCMLDoc() or item.isGroupItem(): continue if item.isDocstring(): cmlComment = CMLVersion.find( item.ref.docstring.leadingCMLComments, CMLcc) else: cmlComment = CMLVersion.find( item.ref.leadingCMLComments, CMLcc) if cmlComment is not None: cmlComment.removeFromText(editor) QApplication.processEvents() self.parent().redrawNow() self.restoreSelectionByID(selection) def onRemoveReplacementText(self): """Removing replacement text""" if self.__actionPrerequisites(): # Memorize the current selection selection = self.serializeSelection() editor = self.selectedItems()[0].getEditor() with editor: for item in self.sortSelectedReverse(): cmlComment = CMLVersion.find(item.ref.leadingCMLComments, CMLrt) if cmlComment is not None: cmlComment.removeFromText(editor) QApplication.processEvents() self.parent().redrawNow() self.restoreSelectionByID(selection) def areSelectedOfTypes(self, matchList): """Checks if the selected items belong to the match""" # match is a list of pairs [kind, subKind] # None would mean 'match any' selectedItems = self.selectedItems() if selectedItems: for selectedItem in selectedItems: for kind, subKind in matchList: match = True if kind is not None: if kind != selectedItem.kind: match = False if subKind is not None: if subKind != selectedItem.subKind: match = False if match: break else: return False return True return False def __createDocFile(self, link, fromFile): """Creates the doc file if needed""" fName, _, errMsg = preResolveLinkPath(link, fromFile, True) if errMsg: logging.error(errMsg) return None if os.path.exists(fName): return fName try: os.makedirs(os.path.dirname(fName), exist_ok=True) with open(fName, 'w') as f: pass except Exception as exc: logging.error('Error creating the documentation file ' + fName + ': ' + str(exc)) return None return fName def onEditDoc(self): """Editing the CML doc comment""" if not self.__actionPrerequisites(): return selectedItem = self.selectedItems()[0] # Exactly one is selected editor = selectedItem.getEditor() fileName = editor._parent.getFileName() if not fileName: fileName = editor._parent.getShortName() # It could be a CML doc or an item which has a CML doc if selectedItem.isComment(): cmlRef = selectedItem.cmlRef else: # If not found then it means the doc link needs to be created cmlRef = self.__findCMLinItem(selectedItem, CMLdoc) dlg = DocLinkAnchorDialog('Add' if cmlRef is None else 'Edit', cmlRef, fileName, self.parent()) if dlg.exec_(): link = dlg.linkEdit.text().strip() anchor = dlg.anchorEdit.text().strip() title = dlg.title() needToCreate = dlg.needToCreate() # First create a file if asked if needToCreate: docFileName = self.__createDocFile(link, fileName) if not docFileName: return selection = self.serializeSelection() with editor: # Now insert a new cml comment or update existing if cmlRef: # It is editing, the comment exists lineNo = cmlRef.ref.beginLine pos = cmlRef.ref.beginPos cmlRef.removeFromText(editor) bgColor = cmlRef.bgColor fgColor = cmlRef.fgColor border = cmlRef.border else: # It is a new doc link lineNo = selectedItem.getFirstLine() pos = selectedItem.ref.body.beginPos bgColor = None fgColor = None border = None line = CMLdoc.generate(link, anchor, title, bgColor, fgColor, border, pos) editor.insertLines(line, lineNo) QApplication.processEvents() self.parent().redrawNow() self.restoreSelectionByID(selection) @staticmethod def __getAutoDocFileName(fileName): """Forms the auto doc file name""" # Markdown is used as a default documentation format fBaseName = os.path.basename(fileName) if '.' in fBaseName: fileExtension = fBaseName.split('.')[-1] fBaseName = fBaseName[:-len(fileExtension)] + 'md' else: fBaseName += '.md' project = GlobalData().project if project.isProjectFile(fileName): projectDir = project.getProjectDir() relativePath = fileName[len(projectDir):] projectName = project.getProjectName() if relativePath.startswith(projectName): relativePath = relativePath.replace(projectName, '', 1) return os.path.normpath( os.path.sep.join([projectDir + 'doc', os.path.dirname(relativePath), fBaseName])) return os.path.normpath( os.path.sep.join([os.path.dirname(fileName), 'doc', fBaseName])) def onAutoAddDoc(self): """Create a doc file, add a link and open for editing""" if not self.__actionPrerequisites(): return selectedItem = self.selectedItems()[0] # Exactly one is selected editor = selectedItem.getEditor() fileName = editor._parent.getFileName() if not fileName: logging.error('Save file before invoking auto doc') return needContent = False newAnchor = 'doc' + str(uuid.uuid4().fields[-1])[-6:] docFileName = self.__getAutoDocFileName(fileName) if not os.path.exists(docFileName): # Create file and populate with the default content try: os.makedirs(os.path.dirname(docFileName), exist_ok=True) with open(docFileName, 'w') as f: pass except Exception as exc: logging.error('Error creating the documentation file ' + docFileName + ': ' + str(exc)) return needContent = True project = GlobalData().project if project.isProjectFile(docFileName): link = project.getRelativePath(docFileName) else: link = os.path.relpath(docFileName, fileName) # Insert a doc link with editor: lineNo = selectedItem.getFirstLine() line = CMLdoc.generate(link, newAnchor, 'See documentation', None, None, None, selectedItem.ref.body.beginPos) editor.insertLines(line, lineNo) QApplication.processEvents() self.parent().redrawNow() # Open the file if GlobalData().mainWindow.openFile(docFileName, -1): if needContent: widget = GlobalData().mainWindow.em.getWidgetForFileName(docFileName) editor = widget.getEditor() editor.text = getDefaultFileDoc(fileName, newAnchor) editor.document().setModified(False) def onRemoveDoc(self): """Removing the CML doc comment""" if not self.__actionPrerequisites(): return editor = self.selectedItems()[0].getEditor() with editor: for item in self.sortSelectedReverse(): cmlComment = CMLVersion.find(item.ref.leadingCMLComments, CMLdoc) if cmlComment is not None: cmlComment.removeFromText(editor) QApplication.processEvents() self.parent().redrawNow() def countInSelected(self, matchList): """Counts the number of matching items in selection""" # match is a list of pairs [kind, subKind] # None would mean 'match any' count = 0 for selectedItem in self.selectedItems(): for kind, subKind in matchList: match = True if kind is not None: if kind != selectedItem.kind: match = False if subKind is not None: if subKind != selectedItem.subKind: match = False if match: count += 1 return count def isInSelected(self, matchList): """Checks if any if the match list items is in the selection""" return self.countInSelected(matchList) > 0 def isDocstringInSelection(self): """True if a docstring item in the selection""" for item in self.selectedItems(): if item.isDocstring(): return True return False def countComments(self): """Count comments in selection""" count = 0 for item in self.selectedItems(): if item.isComment(): count += 1 return count def isCommentInSelection(self): """True if a comment item in the selection""" return self.countComments() > 0 def countItemsWithCML(self, cmlType): """Counts items with have a certain type of a CML comment""" count = 0 for item in self.selectedItems(): if self.__findCMLinItem(item, cmlType) is not None: count += 1 return count def __findCMLinItem(self, item, cmlType): """Finds a related CML item""" if item.isComment(): # Doc links are comments so they are skipped here return None if item.isDocstring(): # Side comments for docstrings? Nonesense! So they are ignored # even if they are collected cml = CMLVersion.find(item.ref.docstring.leadingCMLComments, cmlType) if cml is not None: return cml if hasattr(item.ref, 'leadingCMLComments'): cml = CMLVersion.find(item.ref.leadingCMLComments, cmlType) if cml is not None: return cml if hasattr(item.ref, 'sideCMLComments'): cml = CMLVersion.find(item.ref.sideCMLComments, cmlType) if cml is not None: return cml return None def countGroups(self): """Counts empty, close and open groups""" emptyCount = 0 closeCount = 0 openCount = 0 for item in self.selectedItems(): if item.kind == CellElement.EMPTY_GROUP: emptyCount += 1 elif item.kind == CellElement.COLLAPSED_GROUP: closeCount += 1 elif item.kind == CellElement.OPENED_GROUP_BEGIN: openCount += 1 return emptyCount, closeCount, openCount def countGroupsWithCustomColors(self): """Counts the groups with any color defined""" emptyCount = 0 closeCount = 0 openCount = 0 for item in self.selectedItems(): if item.kind in [CellElement.EMPTY_GROUP, CellElement.COLLAPSED_GROUP, CellElement.OPENED_GROUP_BEGIN]: if item.groupBeginCMLRef.bgColor is not None or \ item.groupBeginCMLRef.fgColor is not None or \ item.groupBeginCMLRef.border is not None: if item.kind == CellElement.EMPTY_GROUP: emptyCount += 1 elif item.kind == CellElement.COLLAPSED_GROUP: closeCount += 1 else: openCount += 1 return emptyCount, closeCount, openCount def countDocWithCustomColors(self): count = 0 for item in self.selectedItems(): if item.isCMLDoc(): if item.cmlRef.bgColor is not None or \ item.cmlRef.fgColor is not None or \ item.cmlRef.border is not None: count += 1 return count def sortSelectedReverse(self): """Sorts the selected items in reverse order""" result = [] for item in self.selectedItems(): itemBegin = item.getAbsPosRange()[0] for index in range(len(result)): if itemBegin > result[index].getAbsPosRange()[0]: result.insert(index, item) break else: result.append(item) return result def sortSelected(self, selected): """Sorts the selected items in direct order""" result = [] for item in selected: itemBegin = item.getAbsPosRange()[0] for index in range(len(result)): if itemBegin < result[index].getAbsPosRange()[0]: result.insert(index, item) break else: result.append(item) return result def __canBeGrouped(self): """True if the selected items can be grouped""" # Cannot import it at the top... from .flowuiwidget import SMART_ZOOM_ALL, SMART_ZOOM_NO_CONTENT if Settings()['smartZoom'] not in [SMART_ZOOM_ALL, SMART_ZOOM_NO_CONTENT]: return False if self.__areAllSelectedComments(): return False if self.__areScopeDocstringOrCommentSelected(): return False if self.__isModuleSelected(): return False # Extend the selection with all the selected items comments selected = self.__extendSelectionForGrouping() if self.__areLoneCommentsSelected(selected): return False if self.__areIncompleteScopeSelected(selected): return False scopeCoveredRegions = self.__getSelectedScopeRegions(selected) # The __areIfFullySelected() also updates the regions with # fully selected if regions if not self.__areIfFullySelected(selected, scopeCoveredRegions): return False selected = self.sortSelected(selected) begin = selected[0].getAbsPosRange()[0] end = selected[-1].getAbsPosRange()[1] if not self.__isSelectionContinuous(selected, scopeCoveredRegions, begin, end): return False if self.__moreThanOneIfBranchSelected(selected, scopeCoveredRegions): return False return True def __areAllSelectedComments(self): """True if all selected items are comments""" for item in self.selectedItems(): if not item.isComment(): return False return True def __areScopeDocstringOrCommentSelected(self): for item in self.selectedItems(): if item.scopedItem(): if item.subKind in [ScopeCellElement.SIDE_COMMENT, ScopeCellElement.DOCSTRING]: return True return False def __isModuleSelected(self): """True if the whole module is selected""" for item in self.selectedItems(): if item.kind == CellElement.FILE_SCOPE: return True return False def __areIncompleteScopeSelected(self, selected): """True if an incomplete scope selected""" for item in selected: if item.kind in [CellElement.FOR_SCOPE, CellElement.WHILE_SCOPE]: if item.ref.elsePart: for relatedItem in self.findItemsForRef(item.ref.elsePart): if relatedItem not in selected: return True elif item.kind in [CellElement.TRY_SCOPE]: # It could be that the exception blocks are hidden, so there # will be exactly one more item instead of many and that item # will have a ref which matches the try scope. exceptPartCount = 0 for exceptPart in item.ref.exceptParts: for relatedItem in self.findItemsForRef(exceptPart): exceptPartCount += 1 if relatedItem not in selected: return True if exceptPartCount == 0: # here: no except blocks on the diagram, they are collapsed tryItems = self.findItemsForRef(item.ref) for tryItem in tryItems: if tryItem.kind == CellElement.EXCEPT_MINIMIZED: if not tryItem.isSelected(): return True break else: # The minimized except is not selected return True if item.ref.elsePart: for relatedItem in self.findItemsForRef(item.ref.elsePart): if relatedItem not in selected: return True if item.ref.finallyPart: for relatedItem in self.findItemsForRef(item.ref.finallyPart): if relatedItem not in selected: return True elif item.kind in [CellElement.ELSE_SCOPE, CellElement.EXCEPT_SCOPE, CellElement.FINALLY_SCOPE]: for relatedItem in self.findItemsForRef(item.leaderRef): if relatedItem not in selected: return True elif item.kind == CellElement.EXCEPT_MINIMIZED: # here: no except blocks on the diagram, they are collapsed tryItems = self.findItemsForRef(item.ref) for tryItem in tryItems: if tryItem.kind == CellElement.TRY_SCOPE: if tryItem.subKind == ScopeCellElement.TOP_LEFT: if not tryItem.isSelected(): return True break else: # The try is not selected return True return False def __extendSelectionForGrouping(self): """Extends the selection with the leading and side comments""" boundComments = [] selected = self.selectedItems() for item in selected: if not item.isComment() and not self.isOpenGroupItem(item): for relatedItem in self.findItemsForRef(item.ref): if relatedItem not in selected: boundComments.append(relatedItem) return selected + boundComments def __areLoneCommentsSelected(self, selected): """True if there are comments selected which have no main item selected""" for item in selected: if item.isComment(): if item.kind in [CellElement.SIDE_COMMENT, CellElement.LEADING_COMMENT, CellElement.ABOVE_COMMENT]: for relatedItem in self.findItemsForRef(item.ref): if relatedItem not in selected: return True return False def __getLineRange(self, selected): first = selected[0] last = selected[-1] if first.kind == CellElement.OPENED_GROUP_BEGIN: firstLine = first.groupBeginCMLRef.ref.parts[0].beginLine pos = first.groupBeginCMLRef.ref.parts[0].beginPos else: firstLine = first.getLineRange()[0] pos = first.ref.beginPos if last.scopedItem(): lastLine = last.ref.endLine elif last.kind == CellElement.OPENED_GROUP_BEGIN: lastLine = last.groupEndCMLRef.ref.parts[-1].endLine else: lastLine = last.getLineRange()[1] return firstLine, lastLine, pos def __getSelectedScopeRegions(self, selected): """Provides the regions of the selected scope items""" coveredRegions = [] for item in selected: if item.scopedItem(): if item.subKind in [ScopeCellElement.TOP_LEFT]: if item.ref.leadingComment: coveredRegions.append((item.ref.leadingComment.begin, item.ref.end)) else: coveredRegions.append((item.ref.begin, item.ref.end)) elif item.kind == CellElement.OPENED_GROUP_BEGIN: coveredRegions.append(item.getAbsPosRange()) return coveredRegions def __areIfFullySelected(self, selected, regions): """Checks if selected IFs are fully selected""" for item in selected: if item.kind == CellElement.IF: ifBegin = item.ref.begin ifEnd = item.ref.end for item in self.items(): if item.isProxyItem(): continue if item.scopedItem(): if item.subKind not in [ScopeCellElement.TOP_LEFT, ScopeCellElement.DOCSTRING, ScopeCellElement.SIDE_COMMENT]: continue if item in selected: continue itemRange = item.getAbsPosRange() if self.isInRegion(itemRange[0], itemRange[1], regions): continue if itemRange[0] > ifBegin and itemRange[0] < ifEnd: return False if itemRange[1] > ifBegin and itemRange[1] < ifEnd: return False regions.append([ifBegin, ifEnd]) return True @staticmethod def isInRegion(start, finish, regions): for region in regions: if start >= region[0] and finish <= region[1]: return True return False def __isSelectionContinuous(self, selected, regions, begin, end): """Checks if the selection is continuous""" for item in self.items(): if item.isProxyItem(): continue if item.scopedItem(): if item.subKind not in [ScopeCellElement.TOP_LEFT, ScopeCellElement.DOCSTRING, ScopeCellElement.SIDE_COMMENT]: continue if item in selected: continue itemRange = item.getAbsPosRange() if self.isInRegion(itemRange[0], itemRange[1], regions): continue # It is important to keep < and > instead of <= and >= # This is because the scopes start with the first statement if itemRange[0] > begin and itemRange[0] < end: return False if itemRange[1] > begin and itemRange[1] < end: return False return True def __moreThanOneIfBranchSelected(self, selected, regions): """Checks that the continuous selected items belong to more than one not selected IF statements """ ifRef = None for item in selected: if item.kind != CellElement.IF: itemRange = item.getAbsPosRange() if item.kind != CellElement.OPENED_GROUP_BEGIN: if self.isInRegion(itemRange[0], itemRange[1], regions): # Here: an item is in a selected scope item, in a selected # open group or in a fully selected if continue # Test if an item belongs to an if statement branch if item.kind in [CellElement.OPENED_GROUP_BEGIN, CellElement.EMPTY_GROUP, CellElement.COLLAPSED_GROUP]: branchId = item.groupBeginCMLRef.ref.getParentIfID() elif item.kind in [CellElement.INDEPENDENT_DOC, CellElement.LEADING_DOC, CellElement.ABOVE_DOC]: branchId = item.cmlRef.ref.getParentIfID() else: branchId = item.ref.getParentIfID() if branchId is not None: if ifRef is None: ifRef = branchId else: if branchId != ifRef: # Selected items belong to more than one branch return True return False
class EditorContextMenuMixin: """Encapsulates the context menu handling""" def __init__(self): self.encodingReloadMenu = QMenu("Set &encoding and reload") self.encodingReloadActGrp = QActionGroup(self) self.encodingWriteMenu = QMenu("Set encodin&g") self.encodingWriteActGrp = QActionGroup(self) mainWindow = GlobalData().mainWindow editorsManager = mainWindow.editorsManagerWidget.editorsManager self._menu = QMenu(self) self.__menuUndo = self._menu.addAction(getIcon('undo.png'), '&Undo', self.onUndo, "Ctrl+Z") self.__menuRedo = self._menu.addAction(getIcon('redo.png'), '&Redo', self.onRedo, "Ctrl+Y") self._menu.addSeparator() self.__menuCut = self._menu.addAction(getIcon('cutmenu.png'), 'Cu&t', self.onShiftDel, "Ctrl+X") self.__menuCopy = self._menu.addAction(getIcon('copymenu.png'), '&Copy', self.onCtrlC, "Ctrl+C") self.__menuPaste = self._menu.addAction(getIcon('pastemenu.png'), '&Paste', self.paste, "Ctrl+V") self.__menuSelectAll = self._menu.addAction( getIcon('selectallmenu.png'), 'Select &all', self.selectAll, "Ctrl+A") self._menu.addSeparator() self.__initReloadEncodingMenu() self.encodingReloadMenu.setIcon(getIcon('textencoding.png')) self._menu.addMenu(self.encodingReloadMenu) self.__initWriteEncodingMenu() self.encodingWriteMenu.setIcon(getIcon('textencoding.png')) menu = self._menu.addMenu(self.encodingWriteMenu) self.__menuClearEncoding = self._menu.addAction( getIcon('clearmenu.png'), 'Clear explicit encoding', self.__onClearEncoding) self._menu.addSeparator() menu = self._menu.addMenu(self.__initToolsMenu()) menu.setIcon(getIcon('toolsmenu.png')) self._menu.addSeparator() menu = self._menu.addMenu(self.__initDiagramsMenu()) menu.setIcon(getIcon('diagramsmenu.png')) self._menu.addSeparator() self.__menuOpenAsFile = self._menu.addAction(getIcon('filemenu.png'), 'O&pen as file', self.openAsFile) self.__menuDownloadAndShow = self._menu.addAction( getIcon('filemenu.png'), 'Do&wnload and show', self.downloadAndShow) self.__menuOpenInBrowser = self._menu.addAction( getIcon('homepagemenu.png'), 'Open in browser', self.openInBrowser) self._menu.addSeparator() self.__menuHighlightInPrj = self._menu.addAction( getIcon("highlightmenu.png"), "&Highlight in project browser", editorsManager.onHighlightInPrj) self.__menuHighlightInFS = self._menu.addAction( getIcon("highlightmenu.png"), "H&ighlight in file system browser", editorsManager.onHighlightInFS) self._menuHighlightInOutline = self._menu.addAction( getIcon("highlightmenu.png"), "Highlight in &outline browser", self.highlightInOutline, 'Ctrl+B') # Plugins support self.__pluginMenuSeparator = self._menu.addSeparator() mainWindow = GlobalData().mainWindow editorsManager = mainWindow.editorsManagerWidget.editorsManager registeredMenus = editorsManager.getPluginMenus() if registeredMenus: for path in registeredMenus: self._menu.addMenu(registeredMenus[path]) else: self.__pluginMenuSeparator.setVisible(False) editorsManager.sigPluginContextMenuAdded.connect( self.__onPluginMenuAdded) editorsManager.sigPluginContextMenuRemoved.connect( self.__onPluginMenuRemoved) def __initReloadEncodingMenu(self): """Creates the encoding menu for reloading the existing file""" for encoding in sorted(SUPPORTED_CODECS): act = self.encodingReloadMenu.addAction(encoding) act.setCheckable(True) act.setData(encoding) self.encodingReloadActGrp.addAction(act) self.encodingReloadMenu.triggered.connect(self.__onReloadWithEncoding) def __initWriteEncodingMenu(self): """Creates the encoding menu for further read/write operations""" for encoding in sorted(SUPPORTED_CODECS): act = self.encodingWriteMenu.addAction(encoding) act.setCheckable(True) act.setData(encoding) self.encodingWriteActGrp.addAction(act) self.encodingWriteMenu.triggered.connect(self.__onReadWriteEncoding) def __initToolsMenu(self): """Creates the tools menu""" self.toolsMenu = QMenu('Python too&ls') self.runAct = self.toolsMenu.addAction(getIcon('run.png'), 'Run script', self._parent.onRunScript) self.runParamAct = self.toolsMenu.addAction( getIcon('paramsmenu.png'), 'Set parameters and run', self._parent.onRunScriptDlg) self.toolsMenu.addSeparator() self.profileAct = self.toolsMenu.addAction( getIcon('profile.png'), 'Profile script', self._parent.onProfileScript) self.profileParamAct = self.toolsMenu.addAction( getIcon('paramsmenu.png'), 'Set parameters and profile', self._parent.onProfileScriptDlg) self.toolsMenu.addSeparator() self.disasmMenu = QMenu('Disassembly') self.disasmMenu.setIcon(getIcon('disassembly.png')) self.disasmAct0 = self.disasmMenu.addAction( getIcon(''), 'Disassembly (no optimization)', self._onDisasm0) self.disasmAct1 = self.disasmMenu.addAction( getIcon(''), 'Disassembly (optimization level 1)', self._onDisasm1) self.disasmAct2 = self.disasmMenu.addAction( getIcon(''), 'Disassembly (optimization level 2)', self._onDisasm2) self.toolsMenu.addMenu(self.disasmMenu) return self.toolsMenu def __initDiagramsMenu(self): """Creates the diagrams menu""" self.diagramsMenu = QMenu("&Diagrams") self.importsDgmAct = self.diagramsMenu.addAction( getIcon('importsdiagram.png'), 'Imports diagram', self._parent.onImportDgm) self.importsDgmParamAct = self.diagramsMenu.addAction( getIcon('paramsmenu.png'), 'Fine tuned imports diagram', self._parent.onImportDgmTuned) return self.diagramsMenu def contextMenuEvent(self, event): """Called just before showing a context menu""" # Accepting needs to suppress the native menu event.accept() isPython = self.isPythonBuffer() readOnly = self.isReadOnly() self.__menuUndo.setEnabled(self.document().isUndoAvailable()) self.__menuRedo.setEnabled(self.document().isRedoAvailable()) self.__menuCut.setEnabled(not readOnly) self.__menuPaste.setEnabled(QApplication.clipboard().text() != "" and not readOnly) fileName = self._parent.getFileName() absFileName = os.path.isabs(fileName) self.__menuOpenAsFile.setEnabled(self.openAsFileAvailable()) self.__menuDownloadAndShow.setEnabled(self.downloadAndShowAvailable()) self.__menuOpenInBrowser.setEnabled(self.downloadAndShowAvailable()) self.__menuHighlightInPrj.setEnabled( absFileName and GlobalData().project.isProjectFile(fileName)) self.__menuHighlightInFS.setEnabled(absFileName) self._menuHighlightInOutline.setEnabled(isPython) self._menuHighlightInOutline.setEnabled(isPython) self.toolsMenu.setEnabled(isPython) if isPython: runEnabled = self._parent.runScriptButton.isEnabled() self.runAct.setEnabled(runEnabled) self.runParamAct.setEnabled(runEnabled) self.profileAct.setEnabled(runEnabled) self.profileParamAct.setEnabled(runEnabled) if absFileName: self.__menuClearEncoding.setEnabled( getFileEncoding(fileName) is not None) else: self.__menuClearEncoding.setEnabled( self.explicitUserEncoding is not None) # Check the proper encoding in the menu encoding = 'undefined' if absFileName: enc = getFileEncoding(fileName) if enc: encoding = enc else: if self.explicitUserEncoding: encoding = self.explicitUserEncoding encoding = getNormalizedEncoding(encoding, False) if absFileName: for act in self.encodingReloadActGrp.actions(): act.setChecked(encoding == getNormalizedEncoding(act.data())) else: self.encodingReloadMenu.setEnabled(False) for act in self.encodingWriteActGrp.actions(): act.setChecked(encoding == getNormalizedEncoding(act.data())) # Show the menu self._menu.popup(event.globalPos()) def __isSameEncodingAsCurrent(self, enc): """True if the same encoding has already been set""" fileName = self._parent.getFileName() if not os.path.isabs(fileName): # New unsaved yet file if not self.explicitUserEncoding: return False return getNormalizedEncoding(enc) == getNormalizedEncoding( self.explicitUserEncoding) # Existed before or just saved new file currentEnc = getFileEncoding(fileName) if not currentEnc: return False return getNormalizedEncoding(currentEnc) == getNormalizedEncoding(enc) def __onReloadWithEncoding(self, act): """Triggered when encoding is selected""" # The method is called only for the existing disk files encoding = act.data() if self.__isSameEncodingAsCurrent(encoding): return if self.document().isModified(): res = QMessageBox.warning( self, 'Continue loosing changes', '<p>The buffer has unsaved changes. Are you sure to continue ' 'reloading the content using ' + encoding + ' encoding and ' 'loosing the changes?</p>', QMessageBox.StandardButtons(QMessageBox.Cancel | QMessageBox.Yes), QMessageBox.Cancel) if res == QMessageBox.Cancel: return # Do the reload fileName = self._parent.getFileName() setFileEncoding(fileName, encoding) self.__updateFilePosition() self.readFile(fileName) self.__restoreFilePosition() self.__updateMainWindowStatusBar() def __onReadWriteEncoding(self, act): """Sets explicit encoding for further read/write ops""" encoding = act.data() if self.__isSameEncodingAsCurrent(encoding): return # fileName = self._parent.getFileName() # absFileName = os.path.isabs(fileName) self.document().setModified(True) self.explicitUserEncoding = encoding self.__updateMainWindowStatusBar() def __onClearEncoding(self): """Clears the explicitly set encoding""" self.explicitUserEncoding = None fileName = self._parent.getFileName() absFileName = os.path.isabs(fileName) if absFileName: setFileEncoding(fileName, None) self.encoding = detectEncodingOnClearExplicit(fileName, self.text) self.__updateMainWindowStatusBar() def onUndo(self): """Undo implementation""" if self.document().isUndoAvailable(): self.undo() self._parent.modificationChanged() def onRedo(self): """Redo implementation""" if self.document().isRedoAvailable(): self.redo() self._parent.modificationChanged() def __onPluginMenuAdded(self, menu, count): """Triggered when a new menu was added""" del count # unused argument self._menu.addMenu(menu) self.__pluginMenuSeparator.setVisible(True) def __onDisasm(self, optimization): """Common implementation""" if self.isPythonBuffer(): if os.path.isabs(self._parent.getFileName()): if not self._parent.isModified(): GlobalData().mainWindow.showFileDisassembly( self._parent.getFileName(), optimization) return fileName = self._parent.getFileName() if not fileName: fileName = self._parent.getShortName() encoding = self.encoding if not encoding: encoding = detectNewFileWriteEncoding(self, fileName) GlobalData().mainWindow.showBufferDisassembly( self.text, encoding, fileName, optimization) def _onDisasm0(self): """Triggered to disassemble the buffer without optimization""" self.__onDisasm(OPT_NO_OPTIMIZATION) def _onDisasm1(self): """Triggered to disassemble the buffer with optimization level 1""" self.__onDisasm(OPT_OPTIMIZE_ASSERT) def _onDisasm2(self): """Triggered to disassemble the buffer with optimization level 2""" self.__onDisasm(OPT_OPTIMIZE_DOCSTRINGS) def __onPluginMenuRemoved(self, menu, count): """Triggered when a menu was deleted""" self._menu.removeAction(menu.menuAction()) self.__pluginMenuSeparator.setVisible(count != 0) def highlightInOutline(self): """Triggered when highlight in outline browser is requested""" if self.isPythonBuffer(): info = getBriefModuleInfoFromMemory(self.text) context = getContext(self, info, True, False) line, _ = self.cursorPosition GlobalData().mainWindow.highlightInOutline(context, int(line) + 1) self.setFocus() @staticmethod def __updateMainWindowStatusBar(): """Updates the main window status bar""" mainWindow = GlobalData().mainWindow editorsManager = mainWindow.editorsManagerWidget.editorsManager editorsManager.updateStatusBar() @staticmethod def __updateFilePosition(): """Updates the position in a file""" mainWindow = GlobalData().mainWindow editorsManager = mainWindow.editorsManagerWidget.editorsManager editorsManager.updateFilePosition(None) @staticmethod def __restoreFilePosition(): """Restores the position in a file""" mainWindow = GlobalData().mainWindow editorsManager = mainWindow.editorsManagerWidget.editorsManager editorsManager.restoreFilePosition(None)
class PylintPlugin(WizardInterface): """Codimension pylint plugin""" def __init__(self): WizardInterface.__init__(self) self.__pylintDriver = None self.__resultViewer = None self.__bufferRunAction = None self.__bufferGenerateAction = None self.__globalShortcut = None self.__mainMenu = None self.__mainMenuSeparator = None self.__mainRunAction = None self.__mainGenerateAction = None @staticmethod def isIDEVersionCompatible(ideVersion): """Checks if the IDE version is compatible with the plugin. Codimension makes this call before activating a plugin. The passed ideVersion is a string representing the current IDE version. True should be returned if the plugin is compatible with the IDE. """ return StrictVersion(ideVersion) >= StrictVersion('4.7.1') def activate(self, ideSettings, ideGlobalData): """Activates the plugin. The plugin may override the method to do specific plugin activation handling. ideSettings - reference to the IDE Settings singleton see codimension/src/utils/settings.py ideGlobalData - reference to the IDE global settings see codimension/src/utils/globals.py Note: if overriden do not forget to call the base class activate() """ WizardInterface.activate(self, ideSettings, ideGlobalData) self.__resultViewer = PylintResultViewer(self.ide, PLUGIN_HOME_DIR) self.ide.sideBars['bottom'].addTab( self.__resultViewer, QIcon(PLUGIN_HOME_DIR + 'pylint.png'), 'Pylint', 'pylint', 2) self.ide.sideBars['bottom'].tabButton('pylint', QTabBar.RightSide).resize(0, 0) # The clear call must be here, not in the results viewer __init__() # This is because the viewer has not been inserted into the side bar at # the time of __init__() so the tooltip setting does not work self.__resultViewer.clear() self.__pylintDriver = PylintDriver(self.ide) self.__pylintDriver.sigFinished.connect(self.__pylintFinished) if self.__globalShortcut is None: self.__globalShortcut = QShortcut(QKeySequence('Ctrl+L'), self.ide.mainWindow, self.__run) else: self.__globalShortcut.setKey('Ctrl+L') # Add buttons for _, _, tabWidget in self.ide.editorsManager.getTextEditors(): self.__addButton(tabWidget) # File type changed & new tab self.ide.editorsManager.sigTextEditorTabAdded.connect( self.__textEditorTabAdded) self.ide.editorsManager.sigFileTypeChanged.connect( self.__fileTypeChanged) # Add main menu self.__mainMenu = QMenu('Pylint', self.ide.mainWindow) self.__mainMenu.setIcon(QIcon(PLUGIN_HOME_DIR + 'pylint.png')) self.__mainRunAction = self.__mainMenu.addAction( QIcon(PLUGIN_HOME_DIR + 'pylint.png'), 'Run pylint\t(Ctrl+L)', self.__run) self.__mainGenerateAction = self.__mainMenu.addAction( QIcon(PLUGIN_HOME_DIR + 'generate.png'), 'Generate/open pylintrc file', self.__generate) toolsMenu = self.ide.mainWindow.menuBar().findChild(QMenu, 'tools') self.__mainMenuSeparator = toolsMenu.addSeparator() toolsMenu.addMenu(self.__mainMenu) self.__mainMenu.aboutToShow.connect(self.__mainMenuAboutToShow) def deactivate(self): """Deactivates the plugin. The plugin may override the method to do specific plugin deactivation handling. Note: if overriden do not forget to call the base class deactivate() """ self.__globalShortcut.setKey(0) self.__resultViewer = None self.ide.sideBars['bottom'].removeTab('pylint') self.__pylintDriver = None # Remove buttons for _, _, tabWidget in self.ide.editorsManager.getTextEditors(): pylintAction = tabWidget.toolbar.findChild(QAction, 'pylint') tabWidget.toolbar.removeAction(pylintAction) # deleteLater() is essential. Otherwise the button is not removed # really from the list of children pylintAction.deleteLater() tabWidget.getEditor().modificationChanged.disconnect( self.__modificationChanged) self.ide.editorsManager.sigTextEditorTabAdded.disconnect( self.__textEditorTabAdded) self.ide.editorsManager.sigFileTypeChanged.disconnect( self.__fileTypeChanged) # Remove main menu items self.__mainRunAction.deleteLater() self.__mainRunAction = None self.__mainGenerateAction.deleteLater() self.__mainGenerateAction = None self.__mainMenu.deleteLater() self.__mainMenu = None self.__mainMenuSeparator.deleteLater() self.__mainMenuSeparator = None WizardInterface.deactivate(self) def getConfigFunction(self): """Provides a plugun configuration function. The plugin can provide a function which will be called when the user requests plugin configuring. If a plugin does not require any config parameters then None should be returned. By default no configuring is required. """ return self.configure def populateMainMenu(self, parentMenu): """Populates the main menu. The main menu looks as follows: Plugins - Plugin manager (fixed item) - Separator (fixed item) - <Plugin #1 name> (this is the parentMenu passed) ... If no items were populated by the plugin then there will be no <Plugin #N name> menu item shown. It is suggested to insert plugin configuration item here if so. """ del parentMenu # unused argument def populateFileContextMenu(self, parentMenu): """Populates the file context menu. The file context menu shown in the project viewer window will have an item with a plugin name and subitems which are populated here. If no items were populated then the plugin menu item will not be shown. When a callback is called the corresponding menu item will have attached data with an absolute path to the item. """ del parentMenu # unused argument def populateDirectoryContextMenu(self, parentMenu): """Populates the directory context menu. The directory context menu shown in the project viewer window will have an item with a plugin name and subitems which are populated here. If no items were populated then the plugin menu item will not be shown. When a callback is called the corresponding menu item will have attached data with an absolute path to the directory. """ del parentMenu # unused argument def populateBufferContextMenu(self, parentMenu): """Populates the editing buffer context menu. The buffer context menu shown for the current edited/viewed file will have an item with a plugin name and subitems which are populated here. If no items were populated then the plugin menu item will not be shown. Note: when a buffer context menu is selected by the user it always refers to the current widget. To get access to the current editing widget the plugin can use: self.ide.currentEditorWidget The widget could be of different types and some circumstances should be considered, e.g.: - it could be a new file which has not been saved yet - it could be modified - it could be that the disk file has already been deleted - etc. Having the current widget reference the plugin is able to retrieve the information it needs. """ parentMenu.setIcon(QIcon(PLUGIN_HOME_DIR + 'pylint.png')) self.__bufferRunAction = parentMenu.addAction( QIcon(PLUGIN_HOME_DIR + 'pylint.png'), 'Run pylint\t(Ctrl+L)', self.__run) self.__bufferGenerateAction = parentMenu.addAction( QIcon(PLUGIN_HOME_DIR + 'generate.png'), 'Generate/open pylintrc file', self.__generate) parentMenu.aboutToShow.connect(self.__bufferMenuAboutToShow) def configure(self): """Configure dialog""" PylintPluginConfigDialog(PLUGIN_HOME_DIR, self.ide.mainWindow).exec_() def __canRun(self, editorWidget): """Tells if pylint can be run for the given editor widget""" if self.__pylintDriver.isInProcess(): return False, None if editorWidget.getType() != MainWindowTabWidgetBase.PlainTextEditor: return False, None if not isPythonMime(editorWidget.getMime()): return False, None if editorWidget.isModified(): return False, 'Save changes before running pylint' if not os.path.isabs(editorWidget.getFileName()): return False, 'The new file has never been saved yet. ' \ 'Save it before running pylint' return True, None def __run(self): """Runs the pylint analysis""" editorWidget = self.ide.currentEditorWidget canRun, message = self.__canRun(editorWidget) if not canRun: if message: self.ide.showStatusBarMessage(message) return enc = editorWidget.getEncoding() message = self.__pylintDriver.start(editorWidget.getFileName(), enc) if message is None: self.__switchToRunning() else: logging.error(message) def __generate(self): """[Generates and] opens the pylintrc file""" editorWidget = self.ide.currentEditorWidget fileName = editorWidget.getFileName() if not os.path.isabs(fileName): fileName = None rcfile = self.__pylintDriver.getPylintrc(self.ide, fileName) if not rcfile: if fileName is None and not self.ide.project.isLoaded(): logging.error('Cannot generate pylintrc. ' 'The current buffer file has not been saved yet ' 'and there is no project') return QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) rcfile = self.__pylintDriver.generateRCFile(self.ide, fileName) QApplication.restoreOverrideCursor() if rcfile: if os.path.exists(rcfile): self.ide.mainWindow.openFile(rcfile, 0) return # It really could be only the rc generating error logging.error('Error generating pylintrc file ' + str(rcfile)) def __pylintFinished(self, results): """Pylint has finished""" self.__switchToIdle() error = results.get('ProcessError', None) if error: logging.error(error) else: self.__resultViewer.showResults(results) self.ide.mainWindow.activateBottomTab('pylint') def __switchToRunning(self): """Switching to the running mode""" QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) # disable buttons for _, _, tabWidget in self.ide.editorsManager.getTextEditors(): pylintAction = tabWidget.toolbar.findChild(QAction, 'pylint') if pylintAction is not None: pylintAction.setEnabled(False) # disable menu def __switchToIdle(self): """Switching to the idle mode""" QApplication.restoreOverrideCursor() # enable buttons for _, _, tabWidget in self.ide.editorsManager.getTextEditors(): pylintAction = tabWidget.toolbar.findChild(QAction, 'pylint') if pylintAction is not None: pylintAction.setEnabled(self.__canRun(tabWidget)[0]) # enable menu def __addButton(self, tabWidget): """Adds a button to the editor toolbar""" pylintButton = QAction(QIcon(PLUGIN_HOME_DIR + 'pylint.png'), 'Run pylint (Ctrl+L)', tabWidget.toolbar) pylintButton.setEnabled(self.__canRun(tabWidget)[0]) pylintButton.triggered.connect(self.__run) pylintButton.setObjectName('pylint') beforeWidget = tabWidget.toolbar.findChild(QAction, 'deadCodeScriptButton') tabWidget.toolbar.insertAction(beforeWidget, pylintButton) tabWidget.getEditor().modificationChanged.connect( self.__modificationChanged) def __modificationChanged(self): """Triggered when one of the text editors changed their mod state""" pylintAction = self.ide.currentEditorWidget.toolbar.findChild( QAction, 'pylint') if pylintAction is not None: pylintAction.setEnabled( self.__canRun(self.ide.currentEditorWidget)[0]) def __textEditorTabAdded(self, tabIndex): """Triggered when a new tab is added""" del tabIndex #unused argument self.__addButton(self.ide.currentEditorWidget) def __fileTypeChanged(self, shortFileName, uuid, mime): """Triggered when a file changed its type""" del shortFileName # unused argument del uuid # unused argument del mime # unused argument # Supposedly it can happened only on the current tab pylintAction = self.ide.currentEditorWidget.toolbar.findChild( QAction, 'pylint') if pylintAction is not None: pylintAction.setEnabled( self.__canRun(self.ide.currentEditorWidget)[0]) def __bufferMenuAboutToShow(self): """The buffer context menu is about to show""" runEnable, generateState = self.__calcRunGenerateState() self.__bufferRunAction.setEnabled(runEnable) self.__bufferGenerateAction.setEnabled(generateState[0]) self.__bufferGenerateAction.setText(generateState[1]) def __mainMenuAboutToShow(self): """The main menu is about to show""" runEnable, generateState = self.__calcRunGenerateState() self.__mainRunAction.setEnabled(runEnable) self.__mainGenerateAction.setEnabled(generateState[0]) self.__mainGenerateAction.setText(generateState[1]) def __calcRunGenerateState(self): """Calculates the enable/disable state of the run/generate menu items""" editorWidget = self.ide.currentEditorWidget defaultGenerateText = 'Open pylintrc file' if editorWidget.getType() != MainWindowTabWidgetBase.PlainTextEditor: return False, (False, defaultGenerateText) if not isPythonMime(editorWidget.getMime()): return False, (False, defaultGenerateText) if self.__pylintDriver.isInProcess(): return False, (False, defaultGenerateText) fileName = editorWidget.getFileName() if not os.path.isabs(fileName): fileName = None rcfile = self.__pylintDriver.getPylintrc(self.ide, fileName) if editorWidget.isModified(): if rcfile: return False, (True, defaultGenerateText) return False, (True, 'Generate and open pylintrc file') # Saved python file and no pylint running if rcfile: return fileName is not None, (True, defaultGenerateText) return fileName is not None, (True, 'Generate and open pylintrc file')