eric: comparison src/eric7/Debugger/CallTraceViewer.py

-:e9e7eca7efee
+:bf71ee032bb4
 class CallTraceViewer(QWidget, Ui_CallTraceViewer):
 """
 Class implementing the Call Trace viewer widget.
 @signal sourceFile(str, int) emitted to show the source of a call/return
 point
 """
 sourceFile = pyqtSignal(str, int)
 def __init__(self, debugServer, debugViewer, parent=None):
 """
 Constructor
 @param debugServer reference to the debug server object
 @type DebugServer
 @param debugViewer reference to the debug viewer object
 @type DebugViewer
 @param parent reference to the parent widget
 @type QWidget
 """
 super().__init__(parent)
 self.setupUi(self)
 self.__dbs = debugServer
 self.__debugViewer = debugViewer
-self.startTraceButton.setIcon(
+self.startTraceButton.setIcon(UI.PixmapCache.getIcon("callTraceStart"))
-UI.PixmapCache.getIcon("callTraceStart"))
+self.stopTraceButton.setIcon(UI.PixmapCache.getIcon("callTraceStop"))
-self.stopTraceButton.setIcon(
-UI.PixmapCache.getIcon("callTraceStop"))
 self.resizeButton.setIcon(UI.PixmapCache.getIcon("resizeColumns"))
 self.clearButton.setIcon(UI.PixmapCache.getIcon("editDelete"))
 self.saveButton.setIcon(UI.PixmapCache.getIcon("fileSave"))
-self.__headerItem = QTreeWidgetItem(
+self.__headerItem = QTreeWidgetItem(["", self.tr("From"), self.tr("To")])
-["", self.tr("From"), self.tr("To")])
 self.__headerItem.setIcon(0, UI.PixmapCache.getIcon("callReturn"))
 self.callTrace.setHeaderItem(self.__headerItem)
 self.__callStack = []
 self.__entryFormat = "{0}:{1} ({2})"
 self.__entryRe = re.compile(r"""(.+):(\d+)\s\((.*)\)""")
 self.__projectMode = False
 self.__project = None
 self.__tracedDebuggerId = ""
 stopOnExit = Preferences.toBool(
-Preferences.getSettings().value("CallTrace/StopOnExit", True))
+Preferences.getSettings().value("CallTrace/StopOnExit", True)
+)
 self.stopCheckBox.setChecked(stopOnExit)
-self.__callTraceEnabled = (Preferences.toBool(
+self.__callTraceEnabled = (
-Preferences.getSettings().value("CallTrace/Enabled", False)) and
+Preferences.toBool(
-not stopOnExit)
+Preferences.getSettings().value("CallTrace/Enabled", False)
+)
+and not stopOnExit
+)
 if self.__callTraceEnabled:
 self.startTraceButton.setEnabled(False)
 else:
 self.stopTraceButton.setEnabled(False)
 self.__dbs.callTraceInfo.connect(self.__addCallTraceInfo)
 self.__dbs.clientExit.connect(self.__clientExit)
 def __setCallTraceEnabled(self, enabled):
 """
 Private slot to set the call trace enabled status.
 @param enabled flag indicating the new state
 @type bool
 """
 if enabled:
-self.__tracedDebuggerId = (
+self.__tracedDebuggerId = self.__debugViewer.getSelectedDebuggerId()
-self.__debugViewer.getSelectedDebuggerId()
-)
 self.__dbs.setCallTraceEnabled(self.__tracedDebuggerId, enabled)
 self.stopTraceButton.setEnabled(enabled)
 self.startTraceButton.setEnabled(not enabled)
 self.__callTraceEnabled = enabled
 Preferences.getSettings().setValue("CallTrace/Enabled", enabled)
 if not enabled:
 for column in range(self.callTrace.columnCount()):
 self.callTrace.resizeColumnToContents(column)
 @pyqtSlot(bool)
 def on_stopCheckBox_clicked(self, checked):
 """
 Private slot to handle a click on the stop check box.
 @param checked state of the check box
 @type bool
 """
 Preferences.getSettings().setValue("CallTrace/StopOnExit", checked)
 @pyqtSlot()
 def on_startTraceButton_clicked(self):
 """
 Private slot to start call tracing.
 """
 self.__setCallTraceEnabled(True)
 @pyqtSlot()
 def on_stopTraceButton_clicked(self):
 """
 Private slot to start call tracing.
 """
 self.__setCallTraceEnabled(False)
 @pyqtSlot()
 def on_resizeButton_clicked(self):
 """
 Private slot to resize the columns of the call trace to their contents.
 """
 for column in range(self.callTrace.columnCount()):
 self.callTrace.resizeColumnToContents(column)
 @pyqtSlot()
 def on_clearButton_clicked(self):
 """
 Private slot to clear the call trace.
 """
 self.clear()
 @pyqtSlot()
 def on_saveButton_clicked(self):
 """
 Private slot to save the call trace info to a file.
 """
 self,
 self.tr("Save Call Trace Info"),
 "",
 self.tr("Text Files (*.txt);;All Files (*)"),
 None,
-EricFileDialog.DontConfirmOverwrite)
+EricFileDialog.DontConfirmOverwrite,
+)
 if fname:
 fpath = pathlib.Path(fname)
 if not fpath.suffix:
 ex = selectedFilter.split("(*")[1].split(")")[0]
 if ex:
 fpath = fpath.with_suffix(ex)
 if fpath.exists():
 res = EricMessageBox.yesNo(
 self,
 self.tr("Save Call Trace Info"),
-self.tr("<p>The file <b>{0}</b> already exists."
+self.tr(
-" Overwrite it?</p>").format(fpath),
+"<p>The file <b>{0}</b> already exists."
-icon=EricMessageBox.Warning)
+" Overwrite it?</p>"
+).format(fpath),
+icon=EricMessageBox.Warning,
+)
 if not res:
 return
 try:
 title = self.tr("Call Trace Info of '{0}'").format(
-self.__tracedDebuggerId)
+self.__tracedDebuggerId
+)
 with fpath.open("w", encoding="utf-8") as f:
 f.write("{0}\n".format(title))
 f.write("{0}\n\n".format(len(title) * "="))
 itm = self.callTrace.topLevelItem(0)
 while itm is not None:
 isCall = itm.data(0, Qt.ItemDataRole.UserRole)
 call = "->" if isCall else "<-"
-f.write("{0} {1} || {2}\n".format(
+f.write(
-call,
+"{0} {1} || {2}\n".format(
-itm.text(1), itm.text(2)))
+call, itm.text(1), itm.text(2)
+)
+)
 itm = self.callTrace.itemBelow(itm)
 except OSError as err:
 EricMessageBox.critical(
 self,
 self.tr("Error saving Call Trace Info"),
-self.tr("""<p>The call trace info could not"""
+self.tr(
-""" be written to <b>{0}</b></p>"""
+"""<p>The call trace info could not"""
-"""<p>Reason: {1}</p>""")
+""" be written to <b>{0}</b></p>"""
-.format(fpath, str(err)))
+"""<p>Reason: {1}</p>"""
+).format(fpath, str(err)),
+)
 @pyqtSlot(QTreeWidgetItem, int)
 def on_callTrace_itemDoubleClicked(self, item, column):
 """
 Private slot to open the double clicked file in an editor.
 @param item reference to the double clicked item
 @type QTreeWidgetItem
 @param column column that was double clicked
 @type int
 """
 # do nothing, if the line info is not an integer
 return
 if self.__projectMode:
 filename = self.__project.getAbsolutePath(filename)
 self.sourceFile.emit(filename, lineno)
 def clear(self):
 """
 Public slot to clear the call trace info.
 """
 self.callTrace.clear()
 self.__callStack = []
 def setProjectMode(self, enabled):
 """
 Public slot to set the call trace viewer to project mode.
 In project mode the call trace info is shown with project relative
 path names.
 @param enabled flag indicating to enable the project mode
 @type bool
 """
 self.__projectMode = enabled
 if enabled and self.__project is None:
 self.__project = ericApp().getObject("Project")
-def __addCallTraceInfo(self, isCall, fromFile, fromLine, fromFunction,
+def __addCallTraceInfo(
-toFile, toLine, toFunction, debuggerId):
+self,
+isCall,
+fromFile,
+fromLine,
+fromFunction,
+toFile,
+toLine,
+toFunction,
+debuggerId,
+):
 """
 Private method to add an entry to the call trace viewer.
 @param isCall flag indicating a 'call'
 @type bool
 @param fromFile name of the originating file
 @type str
 @param fromLine line number in the originating file
 if debuggerId == self.__tracedDebuggerId:
 if isCall:
 icon = UI.PixmapCache.getIcon("forward")
 else:
 icon = UI.PixmapCache.getIcon("back")
-parentItem = (
+parentItem = self.__callStack[-1] if self.__callStack else self.callTrace
-self.__callStack[-1] if self.__callStack else self.callTrace)
 if self.__projectMode:
 fromFile = self.__project.getRelativePath(fromFile)
 toFile = self.__project.getRelativePath(toFile)
 itm = QTreeWidgetItem(
 parentItem,
-["",
+[
-self.__entryFormat.format(fromFile, fromLine, fromFunction),
+"",
-self.__entryFormat.format(toFile, toLine, toFunction)])
+self.__entryFormat.format(fromFile, fromLine, fromFunction),
+self.__entryFormat.format(toFile, toLine, toFunction),
+],
+)
 itm.setIcon(0, icon)
 itm.setData(0, Qt.ItemDataRole.UserRole, isCall)
 itm.setExpanded(True)
 if isCall:
 self.__callStack.append(itm)
 else:
 if self.__callStack:
 self.__callStack.pop(-1)
 def isCallTraceEnabled(self):
 """
 Public method to get the state of the call trace function.
 @return flag indicating the state of the call trace function
 @rtype bool
 """
 return self.__callTraceEnabled
 @pyqtSlot(str, int, str, bool, str)
 def __clientExit(self, program, status, message, quiet, debuggerId):
 """
 Private slot to handle a debug client terminating.
 @param program name of the exited program
 @type str
 @param status exit code of the debugged program
 @type int
 @param message exit message of the debugged program

Mercurial Repositories > eric / file comparison

comparison: src/eric7/Debugger/CallTraceViewer.py

src/eric7/Debugger/CallTraceViewer.py