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 ProfileTableViewer(QWidget): """Profiling results table viewer""" sigEscapePressed = pyqtSignal() def __init__(self, scriptName, params, reportTime, dataFile, stats, parent=None): QWidget.__init__(self, parent) self.__table = ProfilerTreeWidget(self) self.__table.sigEscapePressed.connect(self.__onEsc) self.__script = scriptName self.__stats = stats project = GlobalData().project if project.isLoaded(): self.__projectPrefix = os.path.dirname(project.fileName) else: self.__projectPrefix = os.path.dirname(scriptName) if not self.__projectPrefix.endswith(os.path.sep): self.__projectPrefix += os.path.sep self.__table.setAlternatingRowColors(True) self.__table.setRootIsDecorated(False) self.__table.setItemsExpandable(False) self.__table.setSortingEnabled(True) self.__table.setItemDelegate(NoOutlineHeightDelegate(4)) self.__table.setUniformRowHeights(True) self.__table.setSelectionMode(QAbstractItemView.SingleSelection) self.__table.setSelectionBehavior(QAbstractItemView.SelectRows) headerLabels = [ "", "Calls", "Total time", "Per call", "Cum. time", "Per call", "File name:line", "Function", "Callers", "Callees" ] self.__table.setHeaderLabels(headerLabels) headerItem = self.__table.headerItem() headerItem.setToolTip(0, "Indication if it is an outside function") headerItem.setToolTip( 1, "Actual number of calls/primitive calls " "(not induced via recursion)") headerItem.setToolTip( 2, "Total time spent in function " "(excluding time made in calls " "to sub-functions)") headerItem.setToolTip( 3, "Total time divided by number " "of actual calls") headerItem.setToolTip( 4, "Total time spent in function and all " "subfunctions (from invocation till exit)") headerItem.setToolTip( 5, "Cumulative time divided by number " "of primitive calls") headerItem.setToolTip(6, "Function location") headerItem.setToolTip(7, "Function name") headerItem.setToolTip(8, "Function callers") headerItem.setToolTip(9, "Function callees") self.__table.itemActivated.connect(self.__activated) totalCalls = self.__stats.total_calls # The calls were not induced via recursion totalPrimitiveCalls = self.__stats.prim_calls totalTime = self.__stats.total_tt txt = "<b>Script:</b> " + self.__script + " " + \ params['arguments'] + "<br/>" \ "<b>Run at:</b> " + reportTime + "<br/>" + \ str(totalCalls) + " function calls (" + \ str(totalPrimitiveCalls) + " primitive calls) in " + \ FLOAT_FORMAT % totalTime + " CPU seconds" summary = QLabel(txt, self) summary.setToolTip(txt) summary.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Fixed) summary.setStyleSheet('QLabel {' + getLabelStyle(summary) + '}') vLayout = QVBoxLayout() vLayout.setContentsMargins(0, 0, 0, 0) vLayout.setSpacing(0) vLayout.addWidget(summary) vLayout.addWidget(self.__table) self.setLayout(vLayout) self.__createContextMenu() self.__populate(totalTime) def __onEsc(self): """Triggered when Esc is pressed""" self.sigEscapePressed.emit() def __createContextMenu(self): """Creates context menu for the table raws""" self.__contextMenu = QMenu(self) self.__callersMenu = QMenu("Callers", self) self.__outsideCallersMenu = QMenu("Outside callers", self) self.__calleesMenu = QMenu("Callees", self) self.__outsideCalleesMenu = QMenu("Outside callees", self) self.__contextMenu.addMenu(self.__callersMenu) self.__contextMenu.addMenu(self.__outsideCallersMenu) self.__contextMenu.addSeparator() self.__contextMenu.addMenu(self.__calleesMenu) self.__contextMenu.addMenu(self.__outsideCalleesMenu) self.__callersMenu.triggered.connect(self.__onCallContextMenu) self.__outsideCallersMenu.triggered.connect(self.__onCallContextMenu) self.__calleesMenu.triggered.connect(self.__onCallContextMenu) self.__outsideCalleesMenu.triggered.connect(self.__onCallContextMenu) self.__table.setContextMenuPolicy(Qt.CustomContextMenu) self.__table.customContextMenuRequested.connect(self.__showContextMenu) def __showContextMenu(self, point): """Context menu""" self.__callersMenu.clear() self.__outsideCallersMenu.clear() self.__calleesMenu.clear() self.__outsideCalleesMenu.clear() # Detect what the item was clicked item = self.__table.itemAt(point) funcName = item.getFunctionName() # Build the context menu if item.callersCount() == 0: self.__callersMenu.setEnabled(False) self.__outsideCallersMenu.setEnabled(False) else: callers = self.__stats.stats[item.getFuncIDs()][4] callersList = list(callers.keys()) callersList.sort() for callerFunc in callersList: menuText = self.__getCallLine(callerFunc, callers[callerFunc]) if self.__isOutsideItem(callerFunc[0]): act = self.__outsideCallersMenu.addAction(menuText) else: act = self.__callersMenu.addAction(menuText) funcFileName, funcLine, funcName = \ self.__getLocationAndName(callerFunc) act.setData(funcFileName + ":" + str(funcLine) + ":" + funcName) self.__callersMenu.setEnabled(not self.__callersMenu.isEmpty()) self.__outsideCallersMenu.setEnabled( not self.__outsideCallersMenu.isEmpty()) if item.calleesCount() == 0: self.__calleesMenu.setEnabled(False) self.__outsideCalleesMenu.setEnabled(False) else: callees = self.__stats.all_callees[item.getFuncIDs()] calleesList = list(callees.keys()) calleesList.sort() for calleeFunc in calleesList: menuText = self.__getCallLine(calleeFunc, callees[calleeFunc]) if self.__isOutsideItem(calleeFunc[0]): act = self.__outsideCalleesMenu.addAction(menuText) else: act = self.__calleesMenu.addAction(menuText) funcFileName, funcLine, funcName = \ self.__getLocationAndName(calleeFunc) act.setData(funcFileName + ":" + str(funcLine) + ":" + funcName) self.__calleesMenu.setEnabled(not self.__calleesMenu.isEmpty()) self.__outsideCalleesMenu.setEnabled( not self.__outsideCalleesMenu.isEmpty()) self.__contextMenu.popup(QCursor.pos()) def __resize(self): """Resizes columns to the content""" self.__table.header().resizeSections(QHeaderView.ResizeToContents) self.__table.header().setStretchLastSection(True) self.__table.header().resizeSection(OUTSIDE_COL_INDEX, 28) self.__table.header().setSectionResizeMode(OUTSIDE_COL_INDEX, QHeaderView.Fixed) def setFocus(self): """Set focus to the proper widget""" self.__table.setFocus() def __isOutsideItem(self, fileName): """Detects if the record should be shown as an outside one""" return not fileName.startswith(self.__projectPrefix) def __activated(self, item, column): """Triggered when the item is activated""" try: line = item.getLineNumber() fileName = item.getFileName() if line == 0 or not os.path.isabs(fileName): return GlobalData().mainWindow.openFile(fileName, line) except: logging.error("Could not jump to function location") @staticmethod def __getFuncShortLocation(funcFileName, funcLine): """Provides unified shortened function location""" if funcFileName == "": return "" return os.path.basename(funcFileName) + ":" + str(funcLine) def __getCallLine(self, func, props): """Provides the formatted call line""" funcFileName, funcLine, funcName = self.__getLocationAndName(func) if isinstance(props, tuple): actualCalls, primitiveCalls, totalTime, cumulativeTime = props if primitiveCalls != actualCalls: callsString = str(actualCalls) + "/" + str(primitiveCalls) else: callsString = str(actualCalls) return callsString + "\t" + FLOAT_FORMAT % totalTime + "\t" + \ FLOAT_FORMAT % cumulativeTime + "\t" + \ self.__getFuncShortLocation(funcFileName, funcLine) + \ "(" + funcName + ")" # I've never seen this branch working so it is just in case. # There was something like this in the pstats module return self.__getFuncShortLocation(funcFileName, funcLine) + \ "(" + funcName + ")" @staticmethod def __getLocationAndName(func): """Provides standardized function file name, line and its name""" if func[:2] == ('~', 0): # special case for built-in functions name = func[2] if name.startswith('<') and name.endswith('>'): return "", 0, "{%s}" % name[1:-1] return "", 0, name return func[0], func[1], func[2] def __createItem(self, func, totalCPUTime, primitiveCalls, actualCalls, totalTime, cumulativeTime, timePerCall, cumulativeTimePerCall, callers): """Creates an item to display""" values = [] values.append("") if primitiveCalls == actualCalls: values.append(str(actualCalls)) else: values.append(str(actualCalls) + "/" + str(primitiveCalls)) if totalCPUTime == 0.0: values.append(FLOAT_FORMAT % totalTime) else: values.append(FLOAT_FORMAT % totalTime + " \t(%3.2f%%)" % (totalTime / totalCPUTime * 100)) values.append(FLOAT_FORMAT % timePerCall) values.append(FLOAT_FORMAT % cumulativeTime) values.append(FLOAT_FORMAT % cumulativeTimePerCall) # Location and name will be filled in the item constructor values.append("") values.append("") # Callers callersCount = len(callers) values.append(str(callersCount)) # Callees if func in self.__stats.all_callees: calleesCount = len(self.__stats.all_callees[func]) else: calleesCount = 0 values.append(str(calleesCount)) item = ProfilingTableItem(values, self.__isOutsideItem(func[0]), func) if callersCount != 0: tooltip = "" callersList = list(callers.keys()) callersList.sort() for callerFunc in callersList[:MAX_CALLS_IN_TOOLTIP]: if tooltip != "": tooltip += "\n" tooltip += self.__getCallLine(callerFunc, callers[callerFunc]) if callersCount > MAX_CALLS_IN_TOOLTIP: tooltip += "\n. . ." item.setToolTip(8, tooltip) if calleesCount != 0: callees = self.__stats.all_callees[func] tooltip = "" calleesList = list(callees.keys()) calleesList.sort() for calleeFunc in calleesList[:MAX_CALLS_IN_TOOLTIP]: if tooltip != "": tooltip += "\n" tooltip += self.__getCallLine(calleeFunc, callees[calleeFunc]) if calleesCount > MAX_CALLS_IN_TOOLTIP: tooltip += "\n. . ." item.setToolTip(9, tooltip) self.__table.addTopLevelItem(item) def __populate(self, totalCPUTime): """Populates the data""" for func, (primitiveCalls, actualCalls, totalTime, cumulativeTime, callers) in self.__stats.stats.items(): # Calc time per call if actualCalls == 0: timePerCall = 0.0 else: timePerCall = totalTime / actualCalls # Calc time per cummulative call if primitiveCalls == 0: cumulativeTimePerCall = 0.0 else: cumulativeTimePerCall = cumulativeTime / primitiveCalls self.__createItem(func, totalCPUTime, primitiveCalls, actualCalls, totalTime, cumulativeTime, timePerCall, cumulativeTimePerCall, callers) self.__resize() self.__table.header().setSortIndicator(2, Qt.DescendingOrder) self.__table.sortItems(2, self.__table.header().sortIndicatorOrder()) def togglePath(self, state): """Switches between showing full paths or file names in locations""" for index in range(0, self.__table.topLevelItemCount()): self.__table.topLevelItem(index).updateLocation(state) self.__resize() return def __onCallContextMenu(self, act): """Triggered when a context menu action is requested""" name = str(act.data().toString()) for index in range(0, self.__table.topLevelItemCount()): item = self.__table.topLevelItem(index) if item.match(name): self.__table.clearSelection() self.__table.scrollToItem(item) self.__table.setCurrentItem(item) def onSaveAs(self, fileName): """Saves the table to a file in CSV format""" try: f = open(fileName, "wt") headerItem = self.__table.headerItem() outsideIndex = -1 for index in range(0, headerItem.columnCount()): title = str(headerItem.text(index)) if title == "": outsideIndex = index title = "Outside" if index != 0: f.write(',' + title) else: f.write(title) for index in range(0, self.__table.topLevelItemCount()): item = self.__table.topLevelItem(index) f.write("\n") for column in range(0, item.columnCount()): if column != 0: f.write(',') if column == outsideIndex: if item.isOutside(): f.write("Y") else: f.write("N") else: text = str(item.text(column)) f.write(text.replace('\t', '')) f.close() except Exception as ex: logging.error(ex)