Continued to shorten the code lines to max. 79 characters.

Sun, 06 Oct 2013 19:00:04 +0200

author
Detlev Offenbach <detlev@die-offenbachs.de>
date
Sun, 06 Oct 2013 19:00:04 +0200
changeset 2988
f53c03574697
parent 2987
c99695c0f13a
child 2989
7efa8b8b6903

Continued to shorten the code lines to max. 79 characters.

Debugger/BreakPointModel.py file | annotate | diff | comparison | revisions
Debugger/BreakPointViewer.py file | annotate | diff | comparison | revisions
Debugger/CallStackViewer.py file | annotate | diff | comparison | revisions
Debugger/CallTraceViewer.py file | annotate | diff | comparison | revisions
Debugger/Config.py file | annotate | diff | comparison | revisions
Debugger/DebugServer.py file | annotate | diff | comparison | revisions
Debugger/DebugUI.py file | annotate | diff | comparison | revisions
Debugger/DebugViewer.py file | annotate | diff | comparison | revisions
Debugger/DebuggerInterfaceNone.py file | annotate | diff | comparison | revisions
Debugger/DebuggerInterfacePython.py file | annotate | diff | comparison | revisions
Debugger/DebuggerInterfacePython3.py file | annotate | diff | comparison | revisions
Debugger/DebuggerInterfaceRuby.py file | annotate | diff | comparison | revisions
Debugger/EditBreakpointDialog.py file | annotate | diff | comparison | revisions
Debugger/EditWatchpointDialog.py file | annotate | diff | comparison | revisions
Debugger/ExceptionLogger.py file | annotate | diff | comparison | revisions
Debugger/ExceptionsFilterDialog.py file | annotate | diff | comparison | revisions
Debugger/StartDialog.py file | annotate | diff | comparison | revisions
Debugger/VariablesFilterDialog.py file | annotate | diff | comparison | revisions
Debugger/VariablesViewer.py file | annotate | diff | comparison | revisions
Debugger/WatchPointModel.py file | annotate | diff | comparison | revisions
Debugger/WatchPointViewer.py file | annotate | diff | comparison | revisions
--- a/Debugger/BreakPointModel.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/BreakPointModel.py	Sun Oct 06 19:00:04 2013 +0200
@@ -178,7 +178,7 @@
         else:
             return False
     
-    ############################################################################
+    ###########################################################################
     
     def addBreakPoint(self, fn, line, properties):
         """
@@ -283,7 +283,8 @@
 
     def getBreakPointIndex(self, fn, lineno):
         """
-        Public method to get the index of a breakpoint given by filename and line number.
+        Public method to get the index of a breakpoint given by filename and
+        line number.
         
         @param fn filename of the breakpoint (string)
         @param lineno line number of the breakpoint (integer)
--- a/Debugger/BreakPointViewer.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/BreakPointViewer.py	Sun Oct 06 19:00:04 2013 +0200
@@ -18,8 +18,8 @@
     """
     Class implementing the Breakpoint viewer widget.
     
-    Breakpoints will be shown with all their details. They can be modified through
-    the context menu of this widget.
+    Breakpoints will be shown with all their details. They can be modified
+    through the context menu of this widget.
     
     @signal sourceFile(str, int) emitted to show the source of a breakpoint
     """
@@ -88,7 +88,8 @@
         
     def __resizeColumns(self):
         """
-        Private slot to resize the view when items get added, edited or deleted.
+        Private slot to resize the view when items get added, edited or
+        deleted.
         """
         self.header().resizeSections(QHeaderView.ResizeToContents)
         self.header().setStretchLastSection(True)
@@ -148,7 +149,8 @@
         self.menu.addAction(self.trUtf8("Enable all"), self.__enableAllBreaks)
         self.menu.addSeparator()
         self.menu.addAction(self.trUtf8("Disable"), self.__disableBreak)
-        self.menu.addAction(self.trUtf8("Disable all"), self.__disableAllBreaks)
+        self.menu.addAction(self.trUtf8("Disable all"),
+                            self.__disableAllBreaks)
         self.menu.addSeparator()
         self.menu.addAction(self.trUtf8("Delete"), self.__deleteBreak)
         self.menu.addAction(self.trUtf8("Delete all"), self.__deleteAllBreaks)
@@ -161,11 +163,14 @@
         self.backMenu = QMenu()
         self.backMenu.addAction(self.trUtf8("Add"), self.__addBreak)
         self.backMenuActions["EnableAll"] = \
-            self.backMenu.addAction(self.trUtf8("Enable all"), self.__enableAllBreaks)
+            self.backMenu.addAction(self.trUtf8("Enable all"),
+                                    self.__enableAllBreaks)
         self.backMenuActions["DisableAll"] = \
-            self.backMenu.addAction(self.trUtf8("Disable all"), self.__disableAllBreaks)
+            self.backMenu.addAction(self.trUtf8("Disable all"),
+                                    self.__disableAllBreaks)
         self.backMenuActions["DeleteAll"] = \
-            self.backMenu.addAction(self.trUtf8("Delete all"), self.__deleteAllBreaks)
+            self.backMenu.addAction(self.trUtf8("Delete all"),
+                                    self.__deleteAllBreaks)
         self.backMenu.aboutToShow.connect(self.__showBackMenu)
         self.backMenu.addSeparator()
         self.backMenu.addAction(self.trUtf8("Configure..."), self.__configure)
@@ -175,15 +180,18 @@
         self.multiMenu.addSeparator()
         self.multiMenu.addAction(self.trUtf8("Enable selected"),
             self.__enableSelectedBreaks)
-        self.multiMenu.addAction(self.trUtf8("Enable all"), self.__enableAllBreaks)
+        self.multiMenu.addAction(self.trUtf8("Enable all"),
+                                 self.__enableAllBreaks)
         self.multiMenu.addSeparator()
         self.multiMenu.addAction(self.trUtf8("Disable selected"),
-            self.__disableSelectedBreaks)
-        self.multiMenu.addAction(self.trUtf8("Disable all"), self.__disableAllBreaks)
+                                 self.__disableSelectedBreaks)
+        self.multiMenu.addAction(self.trUtf8("Disable all"),
+                                 self.__disableAllBreaks)
         self.multiMenu.addSeparator()
         self.multiMenu.addAction(self.trUtf8("Delete selected"),
-            self.__deleteSelectedBreaks)
-        self.multiMenu.addAction(self.trUtf8("Delete all"), self.__deleteAllBreaks)
+                                 self.__deleteSelectedBreaks)
+        self.multiMenu.addAction(self.trUtf8("Delete all"),
+                                 self.__deleteAllBreaks)
         self.multiMenu.addSeparator()
         self.multiMenu.addAction(self.trUtf8("Configure..."), self.__configure)
     
@@ -271,7 +279,8 @@
             fn, line, cond, temp, enabled, count = bp[:6]
             
             from .EditBreakpointDialog import EditBreakpointDialog
-            dlg = EditBreakpointDialog((fn, line), (cond, temp, enabled, count),
+            dlg = EditBreakpointDialog(
+                (fn, line), (cond, temp, enabled, count),
                 self.condHistory, self, modal=True)
             if dlg.exec_() == QDialog.Accepted:
                 cond, temp, enabled, count = dlg.getData()
@@ -318,7 +327,8 @@
 
     def __enableSelectedBreaks(self):
         """
-        Private slot to handle the enable selected breakpoints context menu entry.
+        Private slot to handle the enable selected breakpoints context menu
+        entry.
         """
         for index in self.selectedIndexes():
             if index.column() == 0:
@@ -348,7 +358,8 @@
 
     def __disableSelectedBreaks(self):
         """
-        Private slot to handle the disable selected breakpoints context menu entry.
+        Private slot to handle the disable selected breakpoints context menu
+        entry.
         """
         for index in self.selectedIndexes():
             if index.column() == 0:
@@ -373,7 +384,8 @@
 
     def __deleteSelectedBreaks(self):
         """
-        Private slot to handle the delete selected breakpoints context menu entry.
+        Private slot to handle the delete selected breakpoints context menu
+        entry.
         """
         idxList = []
         for index in self.selectedIndexes():
@@ -444,4 +456,5 @@
         """
         Private method to open the configuration dialog.
         """
-        e5App().getObject("UserInterface").showPreferences("debuggerGeneralPage")
+        e5App().getObject("UserInterface").showPreferences(
+            "debuggerGeneralPage")
--- a/Debugger/CallStackViewer.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/CallStackViewer.py	Sun Oct 06 19:00:04 2013 +0200
@@ -102,8 +102,8 @@
         """
         Public slot to show the call stack of the program being debugged.
         
-        @param stack list of tuples with call stack data (file name, line number,
-            function name, formatted argument/values list)
+        @param stack list of tuples with call stack data (file name,
+            line number, function name, formatted argument/values list)
         """
         self.clear()
         for fname, fline, ffunc, fargs in stack:
@@ -186,6 +186,7 @@
                 except IOError as err:
                     E5MessageBox.critical(self,
                         self.trUtf8("Error saving Call Stack Info"),
-                        self.trUtf8("""<p>The call stack info could not be written"""
-                                    """ to <b>{0}</b></p><p>Reason: {1}</p>""")\
+                        self.trUtf8("""<p>The call stack info could not be"""
+                                    """ written to <b>{0}</b></p>"""
+                                    """<p>Reason: {1}</p>""")\
                             .format(fname, str(err)))
--- a/Debugger/CallTraceViewer.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/CallTraceViewer.py	Sun Oct 06 19:00:04 2013 +0200
@@ -24,7 +24,8 @@
     """
     Class implementing the Call Trace viewer widget.
     
-    @signal sourceFile(str, int) emitted to show the source of a call/return point
+    @signal sourceFile(str, int) emitted to show the source of a call/return
+        point
     """
     sourceFile = pyqtSignal(str, int)
     
@@ -40,13 +41,16 @@
         
         self.__dbs = debugServer
         
-        self.startTraceButton.setIcon(UI.PixmapCache.getIcon("callTraceStart.png"))
-        self.stopTraceButton.setIcon(UI.PixmapCache.getIcon("callTraceStop.png"))
+        self.startTraceButton.setIcon(
+            UI.PixmapCache.getIcon("callTraceStart.png"))
+        self.stopTraceButton.setIcon(
+            UI.PixmapCache.getIcon("callTraceStop.png"))
         self.resizeButton.setIcon(UI.PixmapCache.getIcon("resizeColumns.png"))
         self.clearButton.setIcon(UI.PixmapCache.getIcon("editDelete.png"))
         self.saveButton.setIcon(UI.PixmapCache.getIcon("fileSave.png"))
         
-        self.__headerItem = QTreeWidgetItem(["", self.trUtf8("From"), self.trUtf8("To")])
+        self.__headerItem = QTreeWidgetItem(
+            ["", self.trUtf8("From"), self.trUtf8("To")])
         self.__headerItem.setIcon(0, UI.PixmapCache.getIcon("callReturn.png"))
         self.callTrace.setHeaderItem(self.__headerItem)
         
@@ -153,8 +157,9 @@
                 except IOError as err:
                     E5MessageBox.critical(self,
                         self.trUtf8("Error saving Call Trace Info"),
-                        self.trUtf8("""<p>The call trace info could not be written"""
-                                    """ to <b>{0}</b></p><p>Reason: {1}</p>""")\
+                        self.trUtf8("""<p>The call trace info could not"""
+                                    """ be written to <b>{0}</b></p>"""
+                                    """<p>Reason: {1}</p>""")\
                             .format(fname, str(err)))
     
     @pyqtSlot(QTreeWidgetItem, int)
@@ -215,7 +220,8 @@
             icon = UI.PixmapCache.getIcon("forward.png")
         else:
             icon = UI.PixmapCache.getIcon("back.png")
-        parentItem = self.__callStack[-1] if self.__callStack else self.callTrace
+        parentItem = \
+            self.__callStack[-1] if self.__callStack else self.callTrace
         
         if self.__projectMode:
             fromFile = self.__project.getRelativePath(fromFile)
--- a/Debugger/Config.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/Config.py	Sun Oct 06 19:00:04 2013 +0200
@@ -51,7 +51,7 @@
             'Hidden Attributes', 'None', 'Type', 'Boolean', 'Integer',
             'Long Integer', 'Float', 'Complex', 'String', 'Unicode String',
             'Tuple', 'List/Array', 'Dictionary/Hash/Map', 'Dictionary Proxy',
-            'Set', 'File', 'X Range', 'Slice', 'Buffer', 'Class', 'Class Instance',
-            'Class Method', 'Class Property', 'Generator', 'Function',
-            'Builtin Function', 'Code', 'Module', 'Ellipsis',
+            'Set', 'File', 'X Range', 'Slice', 'Buffer', 'Class',
+            'Class Instance', 'Class Method', 'Class Property', 'Generator',
+            'Function', 'Builtin Function', 'Code', 'Module', 'Ellipsis',
             'Traceback', 'Frame', 'Other']
--- a/Debugger/DebugServer.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/DebugServer.py	Sun Oct 06 19:00:04 2013 +0200
@@ -10,7 +10,8 @@
 import os
 
 from PyQt4.QtCore import pyqtSignal, QModelIndex
-from PyQt4.QtNetwork import QTcpServer, QHostAddress, QHostInfo, QNetworkInterface
+from PyQt4.QtNetwork import QTcpServer, QHostAddress, QHostInfo, \
+    QNetworkInterface
 
 from E5Gui.E5Application import e5App
 from E5Gui import E5MessageBox
@@ -35,68 +36,74 @@
     """
     Class implementing the debug server embedded within the IDE.
     
-    @signal clientProcessStdout(str) emitted after the client has sent some output
-            via stdout
-    @signal clientProcessStderr(str) emitted after the client has sent some output
-            via stderr
+    @signal clientProcessStdout(str) emitted after the client has sent some
+        output via stdout
+    @signal clientProcessStderr(str) emitted after the client has sent some
+        output via stderr
     @signal clientOutput(str) emitted after the client has sent some output
-    @signal clientRawInputSent() emitted after the data was sent to the debug client
-    @signal clientLine(filename, lineno, forStack) emitted after the debug client
-            has executed a line of code
+    @signal clientRawInputSent() emitted after the data was sent to the
+        debug client
+    @signal clientLine(filename, lineno, forStack) emitted after the
+        debug client has executed a line of code
     @signal clientStack(stack) emitted after the debug client has executed a
-            line of code
+        line of code
     @signal clientThreadList(currentId, threadList) emitted after a thread list
-            has been received
-    @signal clientThreadSet() emitted after the client has acknowledged the change
-            of the current thread
-    @signal clientVariables(scope, variables) emitted after a variables dump has
-            been received
+        has been received
+    @signal clientThreadSet() emitted after the client has acknowledged the
+        change of the current thread
+    @signal clientVariables(scope, variables) emitted after a variables dump
+        has been received
     @signal clientVariable(scope, variables) emitted after a dump for one class
-            variable has been received
+        variable has been received
     @signal clientStatement(bool) emitted after an interactive command has
-            been executed. The parameter is 0 to indicate that the command is
-            complete and 1 if it needs more input.
-    @signal clientException(exception) emitted after an exception occured on the
-            client side
-    @signal clientSyntaxError(exception) emitted after a syntax error has been detected
-            on the client side
-    @signal clientExit(int) emitted with the exit status after the client has exited
+        been executed. The parameter is 0 to indicate that the command is
+        complete and 1 if it needs more input.
+    @signal clientException(exception) emitted after an exception occured on
+        the client side
+    @signal clientSyntaxError(exception) emitted after a syntax error has been
+        detected on the client side
+    @signal clientExit(int) emitted with the exit status after the client has
+        exited
     @signal clientClearBreak(filename, lineno) emitted after the debug client
-            has decided to clear a temporary breakpoint
-    @signal clientBreakConditionError(fn, lineno) emitted after the client has signaled
-            a syntax error in a breakpoint condition
+        has decided to clear a temporary breakpoint
+    @signal clientBreakConditionError(fn, lineno) emitted after the client has
+        signaled a syntax error in a breakpoint condition
     @signal clientClearWatch(condition) emitted after the debug client
             has decided to clear a temporary watch expression
-    @signal clientWatchConditionError(condition) emitted after the client has signaled
-            a syntax error in a watch expression
-    @signal clientRawInput(prompt, echo) emitted after a raw input request was received
+    @signal clientWatchConditionError(condition) emitted after the client has
+        signaled a syntax error in a watch expression
+    @signal clientRawInput(prompt, echo) emitted after a raw input request was
+        received
     @signal clientBanner(banner) emitted after the client banner was received
-    @signal clientCapabilities(int capabilities, string cltype) emitted after the clients
-            capabilities were received
+    @signal clientCapabilities(int capabilities, string cltype) emitted after
+        the clients capabilities were received
     @signal clientCompletionList(completionList, text) emitted after the client
-            the commandline completion list and the reworked searchstring was
-            received from the client
-    @signal passiveDebugStarted(str, bool) emitted after the debug client has connected in
-            passive debug mode
-    @signal clientGone(bool) emitted if the client went away (planned or unplanned)
-    @signal utPrepared(nrTests, exc_type, exc_value) emitted after the client has
-            loaded a unittest suite
-    @signal utFinished() emitted after the client signalled the end of the unittest
-    @signal utStartTest(testname, testdocu) emitted after the client has started
-            a test
+        the commandline completion list and the reworked searchstring was
+        received from the client
+    @signal passiveDebugStarted(str, bool) emitted after the debug client has
+        connected in passive debug mode
+    @signal clientGone(bool) emitted if the client went away (planned or
+        unplanned)
+    @signal utPrepared(nrTests, exc_type, exc_value) emitted after the client
+        has loaded a unittest suite
+    @signal utFinished() emitted after the client signalled the end of the
+        unittest
+    @signal utStartTest(testname, testdocu) emitted after the client has
+        started a test
     @signal utStopTest() emitted after the client has finished a test
-    @signal utTestFailed(testname, exc_info, id) emitted after the client reported
-            a failed test
-    @signal utTestErrored(testname, exc_info, id) emitted after the client reported
-            an errored test
-    @signal utTestSkipped(testname, reason, id) emitted after the client reported
-            a skipped test
-    @signal utTestFailedExpected(testname, exc_info, id) emitted after the client reported
-            an expected test failure
-    @signal utTestSucceededUnexpected(testname, id) emitted after the client reported
-            an unexpected test success
-    @signal callTraceInfo(isCall, fromFile, fromLine, fromFunction, toFile, toLine, toFunction)
-            emitted after the client reported the call trace data
+    @signal utTestFailed(testname, exc_info, id) emitted after the client
+        reported a failed test
+    @signal utTestErrored(testname, exc_info, id) emitted after the client
+        reported an errored test
+    @signal utTestSkipped(testname, reason, id) emitted after the client
+        reported a skipped test
+    @signal utTestFailedExpected(testname, exc_info, id) emitted after the
+        client reported an expected test failure
+    @signal utTestSucceededUnexpected(testname, id) emitted after the client
+        reported an unexpected test success
+    @signal callTraceInfo(isCall, fromFile, fromLine, fromFunction, toFile,
+        toLine, toFunction) emitted after the client reported the call trace
+        data
     """
     clientClearBreak = pyqtSignal(str, int)
     clientClearWatch = pyqtSignal(str)
@@ -181,13 +188,15 @@
         self.clientClearWatch.connect(self.__clientClearWatchPoint)
         self.newConnection[()].connect(self.__newConnection)
         
-        self.breakpointModel.rowsAboutToBeRemoved.connect(self.__deleteBreakPoints)
+        self.breakpointModel.rowsAboutToBeRemoved.connect(
+            self.__deleteBreakPoints)
         self.breakpointModel.dataAboutToBeChanged.connect(
             self.__breakPointDataAboutToBeChanged)
         self.breakpointModel.dataChanged.connect(self.__changeBreakPoints)
         self.breakpointModel.rowsInserted.connect(self.__addBreakPoints)
         
-        self.watchpointModel.rowsAboutToBeRemoved.connect(self.__deleteWatchPoints)
+        self.watchpointModel.rowsAboutToBeRemoved.connect(
+            self.__deleteWatchPoints)
         self.watchpointModel.dataAboutToBeChanged.connect(
             self.__watchPointDataAboutToBeChanged)
         self.watchpointModel.dataChanged.connect(self.__changeWatchPoints)
@@ -197,9 +206,11 @@
         
     def getHostAddress(self, localhost):
         """
-        Public method to get the IP address or hostname the debug server is listening.
+        Public method to get the IP address or hostname the debug server is
+        listening.
         
-        @param localhost flag indicating to return the address for localhost (boolean)
+        @param localhost flag indicating to return the address for localhost
+            (boolean)
         @return IP address or hostname (string)
         """
         if self.networkInterface == "all":
@@ -218,7 +229,8 @@
         
     def __getNetworkInterfaceAndIndex(self, address):
         """
-        Private method to determine the network interface and the interface index.
+        Private method to determine the network interface and the interface
+        index.
         
         @param address address to determine the info for (string)
         @return tuple of network interface name (string) and index (integer)
@@ -228,7 +240,8 @@
                 addressEntries = networkInterface.addressEntries()
                 if len(addressEntries) > 0:
                     for addressEntry in addressEntries:
-                        if addressEntry.ip().toString().lower() == address.lower():
+                        if addressEntry.ip().toString().lower() == \
+                                address.lower():
                             return networkInterface.humanReadableName(), \
                                     networkInterface.index()
         
@@ -279,7 +292,8 @@
         if shellOnly:
             languages = \
                 [lang for lang in languages \
-                 if self.__clientCapabilities[lang] & DebugClientCapabilities.HasShell]
+                 if self.__clientCapabilities[lang] & 
+                    DebugClientCapabilities.HasShell]
         
         return languages[:]
         
@@ -288,7 +302,8 @@
         Public slot to get the extensions associated with the given language.
         
         @param language language to get extensions for (string)
-        @return tuple of extensions associated with the language (tuple of strings)
+        @return tuple of extensions associated with the language
+            (tuple of strings)
         """
         extensions = []
         for ext, lang in list(self.__clientAssociations.items()):
@@ -308,19 +323,24 @@
                 clientType = self.clientType
             if clientType == "Python2":
                 from .DebuggerInterfacePython import DebuggerInterfacePython
-                self.debuggerInterface = DebuggerInterfacePython(self, self.passive)
+                self.debuggerInterface = DebuggerInterfacePython(
+                    self, self.passive)
             elif clientType == "Python3":
                 from .DebuggerInterfacePython3 import DebuggerInterfacePython3
-                self.debuggerInterface = DebuggerInterfacePython3(self, self.passive)
+                self.debuggerInterface = DebuggerInterfacePython3(
+                    self, self.passive)
             elif clientType == "Ruby":
                 from .DebuggerInterfaceRuby import DebuggerInterfaceRuby
-                self.debuggerInterface = DebuggerInterfaceRuby(self, self.passive)
+                self.debuggerInterface = DebuggerInterfaceRuby(
+                    self, self.passive)
             elif clientType == "None":
                 from .DebuggerInterfaceNone import DebuggerInterfaceNone
-                self.debuggerInterface = DebuggerInterfaceNone(self, self.passive)
+                self.debuggerInterface = DebuggerInterfaceNone(
+                    self, self.passive)
             else:
                 from .DebuggerInterfaceNone import DebuggerInterfaceNone
-                self.debuggerInterface = DebuggerInterfaceNone(self, self.passive)
+                self.debuggerInterface = DebuggerInterfaceNone(
+                    self, self.passive)
                 self.clientType = "None"
         
     def __setClientType(self, clType):
@@ -372,11 +392,12 @@
                                                            runInConsole)
                 else:
                     self.clientProcess, isNetworked = \
-                        self.debuggerInterface.startRemoteForProject(self.serverPort(),
-                                                                     runInConsole)
+                        self.debuggerInterface.startRemoteForProject(
+                            self.serverPort(), runInConsole)
             else:
                 self.clientProcess, isNetworked = \
-                    self.debuggerInterface.startRemote(self.serverPort(), runInConsole)
+                    self.debuggerInterface.startRemote(
+                        self.serverPort(), runInConsole)
             
             if self.clientProcess:
                 self.clientProcess.readyReadStandardError.connect(
@@ -438,7 +459,8 @@
         if self.debugging:
             for row in range(start, end + 1):
                 index = self.breakpointModel.index(row, 0, parentIndex)
-                fn, lineno = self.breakpointModel.getBreakPointByIndex(index)[0:2]
+                fn, lineno = \
+                    self.breakpointModel.getBreakPointByIndex(index)[0:2]
                 self.remoteBreakpoint(fn, lineno, False)
 
     def __changeBreakPoints(self, startIndex, endIndex):
@@ -449,17 +471,20 @@
         @param endIndex ending index of the change breakpoins (QModelIndex)
         """
         if self.debugging:
-            self.__addBreakPoints(QModelIndex(), startIndex.row(), endIndex.row())
+            self.__addBreakPoints(
+                QModelIndex(), startIndex.row(), endIndex.row())
 
     def __breakPointDataAboutToBeChanged(self, startIndex, endIndex):
         """
-        Private slot to handle the dataAboutToBeChanged signal of the breakpoint model.
+        Private slot to handle the dataAboutToBeChanged signal of the
+        breakpoint model.
         
         @param startIndex start index of the rows to be changed (QModelIndex)
         @param endIndex end index of the rows to be changed (QModelIndex)
         """
         if self.debugging:
-            self.__deleteBreakPoints(QModelIndex(), startIndex.row(), endIndex.row())
+            self.__deleteBreakPoints(
+                QModelIndex(), startIndex.row(), endIndex.row())
         
     def __addBreakPoints(self, parentIndex, start, end):
         """
@@ -502,7 +527,8 @@
         Private method to split a remote watch expression.
         
         @param cond remote expression (string)
-        @return tuple of local expression (string) and special condition (string)
+        @return tuple of local expression (string) and special condition
+            (string)
         """
         if cond.endswith(" ??created??"):
             cond, special = cond.split()
@@ -538,7 +564,8 @@
         if self.debugging:
             for row in range(start, end + 1):
                 index = self.watchpointModel.index(row, 0, parentIndex)
-                cond, special = self.watchpointModel.getWatchPointByIndex(index)[0:2]
+                cond, special = \
+                    self.watchpointModel.getWatchPointByIndex(index)[0:2]
                 cond = self.__makeWatchCondition(cond, special)
                 self.__remoteWatchpoint(cond, False)
         
@@ -551,7 +578,8 @@
         @param endIndex end index of the rows to be changed (QModelIndex)
         """
         if self.debugging:
-            self.__deleteWatchPoints(QModelIndex(), startIndex.row(), endIndex.row())
+            self.__deleteWatchPoints(
+                QModelIndex(), startIndex.row(), endIndex.row())
         
     def __addWatchPoints(self, parentIndex, start, end):
         """
@@ -581,7 +609,8 @@
         @param endIndex end index of the rows to be changed (QModelIndex)
         """
         if self.debugging:
-            self.__addWatchPoints(QModelIndex(), startIndex.row(), endIndex.row())
+            self.__addWatchPoints(
+                QModelIndex(), startIndex.row(), endIndex.row())
         
     def getClientCapabilities(self, type):
         """
@@ -605,8 +634,9 @@
             # the peer is not allowed to connect
             res = E5MessageBox.yesNo(None,
                 self.trUtf8("Connection from illegal host"),
-                self.trUtf8("""<p>A connection was attempted by the"""
-                    """ illegal host <b>{0}</b>. Accept this connection?</p>""")\
+                self.trUtf8(
+                    """<p>A connection was attempted by the illegal host"""
+                    """ <b>{0}</b>. Accept this connection?</p>""")\
                     .format(peerAddress),
                 icon=E5MessageBox.Warning)
             if not res:
@@ -618,7 +648,8 @@
                 Preferences.setDebugger("AllowedHosts", allowedHosts)
         
         if self.passive:
-            self.__createDebuggerInterface(Preferences.getDebugger("PassiveDbgType"))
+            self.__createDebuggerInterface(
+                Preferences.getDebugger("PassiveDbgType"))
         
         accepted = self.debuggerInterface.newConnection(sock)
         if accepted:
@@ -673,17 +704,18 @@
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
         @param env environment settings (string)
-        @keyparam autoClearShell flag indicating, that the interpreter window should
-            be cleared (boolean)
-        @keyparam tracePython flag indicating if the Python library should be traced
-            as well (boolean)
-        @keyparam autoContinue flag indicating, that the debugger should not stop
-            at the first executable line (boolean)
+        @keyparam autoClearShell flag indicating, that the interpreter window
+            should be cleared (boolean)
+        @keyparam tracePython flag indicating if the Python library should be
+            traced as well (boolean)
+        @keyparam autoContinue flag indicating, that the debugger should not
+            stop at the first executable line (boolean)
         @keyparam forProject flag indicating a project related action (boolean)
         @keyparam runInConsole flag indicating to start the debugger in a
             console window (boolean)
         @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking (boolean)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
         @keyparam clientType client type to be used (string)
         @keyparam enableCallTrace flag indicating to enable the call trace
             function (boolean)
@@ -696,16 +728,18 @@
             if clientType:
                 self.__setClientType(clientType)
             else:
-                self.__setClientType(self.__clientAssociations[os.path.splitext(fn)[1]])
+                self.__setClientType(
+                    self.__clientAssociations[os.path.splitext(fn)[1]])
         except KeyError:
             self.__setClientType('Python3')    # assume it is a Python3 file
-        self.startClient(False, forProject=forProject, runInConsole=runInConsole)
+        self.startClient(False, forProject=forProject,
+                         runInConsole=runInConsole)
         
         self.setCallTraceEnabled(enableCallTrace)
         self.remoteEnvironment(env)
         
-        self.debuggerInterface.remoteLoad(fn, argv, wd, tracePython, autoContinue,
-                                          autoFork, forkChild)
+        self.debuggerInterface.remoteLoad(fn, argv, wd, tracePython,
+                                          autoContinue, autoFork, forkChild)
         self.debugging = True
         self.running = True
         self.__restoreBreakpoints()
@@ -722,13 +756,14 @@
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
         @param env environment settings (string)
-        @keyparam autoClearShell flag indicating, that the interpreter window should
-            be cleared (boolean)
+        @keyparam autoClearShell flag indicating, that the interpreter window
+            should be cleared (boolean)
         @keyparam forProject flag indicating a project related action (boolean)
         @keyparam runInConsole flag indicating to start the debugger in a
             console window (boolean)
         @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking (boolean)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
         @keyparam clientType client type to be used (string)
         """
         self.__autoClearShell = autoClearShell
@@ -738,10 +773,12 @@
             if clientType:
                 self.__setClientType(clientType)
             else:
-                self.__setClientType(self.__clientAssociations[os.path.splitext(fn)[1]])
+                self.__setClientType(
+                    self.__clientAssociations[os.path.splitext(fn)[1]])
         except KeyError:
             self.__setClientType('Python3')    # assume it is a Python3 file
-        self.startClient(False, forProject=forProject, runInConsole=runInConsole)
+        self.startClient(False, forProject=forProject,
+                         runInConsole=runInConsole)
         
         self.remoteEnvironment(env)
         
@@ -759,8 +796,8 @@
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
         @param env environment settings (string)
-        @keyparam autoClearShell flag indicating, that the interpreter window should
-            be cleared (boolean)
+        @keyparam autoClearShell flag indicating, that the interpreter window
+            should be cleared (boolean)
         @keyparam erase flag indicating that coverage info should be
             cleared first (boolean)
         @keyparam forProject flag indicating a project related action (boolean)
@@ -775,10 +812,12 @@
             if clientType:
                 self.__setClientType(clientType)
             else:
-                self.__setClientType(self.__clientAssociations[os.path.splitext(fn)[1]])
+                self.__setClientType(
+                    self.__clientAssociations[os.path.splitext(fn)[1]])
         except KeyError:
             self.__setClientType('Python3')    # assume it is a Python3 file
-        self.startClient(False, forProject=forProject, runInConsole=runInConsole)
+        self.startClient(False, forProject=forProject,
+                         runInConsole=runInConsole)
         
         self.remoteEnvironment(env)
         
@@ -797,9 +836,10 @@
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
         @param env environment settings (string)
-        @keyparam autoClearShell flag indicating, that the interpreter window should
-            be cleared (boolean)
-        @keyparam erase flag indicating that timing info should be cleared first (boolean)
+        @keyparam autoClearShell flag indicating, that the interpreter window
+            should be cleared (boolean)
+        @keyparam erase flag indicating that timing info should be cleared
+            first (boolean)
         @keyparam forProject flag indicating a project related action (boolean)
         @keyparam runInConsole flag indicating to start the debugger in a
             console window (boolean)
@@ -812,10 +852,12 @@
             if clientType:
                 self.__setClientType(clientType)
             else:
-                self.__setClientType(self.__clientAssociations[os.path.splitext(fn)[1]])
+                self.__setClientType(
+                    self.__clientAssociations[os.path.splitext(fn)[1]])
         except KeyError:
             self.__setClientType('Python3')    # assume it is a Python3 file
-        self.startClient(False, forProject=forProject, runInConsole=runInConsole)
+        self.startClient(False, forProject=forProject,
+                         runInConsole=runInConsole)
         
         self.remoteEnvironment(env)
         
@@ -882,7 +924,8 @@
         
         @param fn filename the breakpoint belongs to (string)
         @param line linenumber of the breakpoint (int)
-        @param enable flag indicating enabling or disabling a breakpoint (boolean)
+        @param enable flag indicating enabling or disabling a breakpoint
+            (boolean)
         """
         self.debuggerInterface.remoteBreakpointEnable(fn, line, enable)
         
@@ -901,7 +944,8 @@
         Private method to set or clear a watch expression.
         
         @param cond expression of the watch expression (string)
-        @param set flag indicating setting or resetting a watch expression (boolean)
+        @param set flag indicating setting or resetting a watch expression
+            (boolean)
         @param temp flag indicating a temporary watch expression (boolean)
         """
         # cond is combination of cond and special (s. watch expression viewer)
@@ -912,14 +956,16 @@
         Private method to enable or disable a watch expression.
         
         @param cond expression of the watch expression (string)
-        @param enable flag indicating enabling or disabling a watch expression (boolean)
+        @param enable flag indicating enabling or disabling a watch expression
+            (boolean)
         """
         # cond is combination of cond and special (s. watch expression viewer)
         self.debuggerInterface.remoteWatchpointEnable(cond, enable)
     
     def __remoteWatchpointIgnore(self, cond, count):
         """
-        Private method to ignore a watch expression the next couple of occurrences.
+        Private method to ignore a watch expression the next couple of
+        occurrences.
         
         @param cond expression of the watch expression (string)
         @param count number of occurrences to ignore (int)
@@ -969,7 +1015,8 @@
         @param var list encoded name of variable to retrieve (string)
         @param framenr framenumber of the variables to retrieve (int)
         """
-        self.debuggerInterface.remoteClientVariable(scope, filter, var, framenr)
+        self.debuggerInterface.remoteClientVariable(
+            scope, filter, var, framenr)
         
     def remoteClientSetFilter(self, scope, filter):
         """
@@ -990,7 +1037,8 @@
         
     def remoteEval(self, arg):
         """
-        Public method to evaluate arg in the current context of the debugged program.
+        Public method to evaluate arg in the current context of the debugged
+        program.
         
         @param arg the arguments to evaluate (string)
         """
@@ -998,7 +1046,8 @@
         
     def remoteExec(self, stmt):
         """
-        Public method to execute stmt in the current context of the debugged program.
+        Public method to execute stmt in the current context of the debugged
+        program.
         
         @param stmt statement to execute (string)
         """
@@ -1025,7 +1074,8 @@
         """
         self.debuggerInterface.remoteCompletion(text)
 
-    def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase, clientType=""):
+    def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase,
+                        clientType=""):
         """
         Public method to prepare a new unittest run.
         
@@ -1033,11 +1083,13 @@
         @param tn the testname to load (string)
         @param tfn the test function name to load tests from (string)
         @param failed list of failed test, if only failed test should be run
-                (list of strings)
-        @param cov flag indicating collection of coverage data is requested (boolean)
+            (list of strings)
+        @param cov flag indicating collection of coverage data is requested
+            (boolean)
         @param covname filename to be used to assemble the coverage caches
-                filename (string)
-        @param coverase flag indicating erasure of coverage data is requested (boolean)
+            filename (string)
+        @param coverase flag indicating erasure of coverage data is requested
+            (boolean)
         @keyparam clientType client type to be used (string)
         """
         # Restart the client if there is already a program loaded.
@@ -1045,7 +1097,8 @@
             if clientType:
                 self.__setClientType(clientType)
             else:
-                self.__setClientType(self.__clientAssociations[os.path.splitext(fn)[1]])
+                self.__setClientType(
+                    self.__clientAssociations[os.path.splitext(fn)[1]])
         except KeyError:
             self.__setClientType('Python3')    # assume it is a Python3 file
         self.startClient(False)
@@ -1114,7 +1167,8 @@
         """
         Public method to process the client variables info.
         
-        @param scope scope of the variables (-1 = empty global, 1 = global, 0 = local)
+        @param scope scope of the variables (-1 = empty global, 1 = global,
+            0 = local)
         @param variables the list of variables from the client
         """
         self.clientVariables.emit(scope, variables)
@@ -1123,7 +1177,8 @@
         """
         Public method to process the client variable info.
         
-        @param scope scope of the variables (-1 = empty global, 1 = global, 0 = local)
+        @param scope scope of the variables (-1 = empty global, 1 = global,
+            0 = local)
         @param variables the list of members of a classvariable from the client
         """
         self.clientVariable.emit(scope, variables)
@@ -1136,26 +1191,31 @@
         """
         self.clientStatement.emit(more)
         
-    def signalClientException(self, exceptionType, exceptionMessage, stackTrace):
+    def signalClientException(self, exceptionType, exceptionMessage,
+                              stackTrace):
         """
         Public method to process the exception info from the client.
         
         @param exceptionType type of exception raised (string)
         @param exceptionMessage message given by the exception (string)
         @param stackTrace list of stack entries with the exception position
-            first. Each stack entry is a list giving the filename and the linenumber.
+            first. Each stack entry is a list giving the filename and the
+            linenumber.
         """
         if self.running:
-            self.clientException.emit(exceptionType, exceptionMessage, stackTrace)
+            self.clientException.emit(exceptionType, exceptionMessage,
+                                      stackTrace)
         
     def signalClientSyntaxError(self, message, filename, lineNo, characterNo):
         """
         Public method to process the syntax error info from the client.
         
         @param message message of the syntax error (string)
-        @param filename translated filename of the syntax error position (string)
+        @param filename translated filename of the syntax error position
+            (string)
         @param lineNo line number of the syntax error position (integer)
-        @param characterNo character number of the syntax error position (integer)
+        @param characterNo character number of the syntax error position
+            (integer)
         """
         if self.running:
             self.clientSyntaxError.emit(message, filename, lineNo, characterNo)
@@ -1373,14 +1433,16 @@
         Private method to restore the breakpoints after a restart.
         """
         if self.debugging:
-            self.__addBreakPoints(QModelIndex(), 0, self.breakpointModel.rowCount() - 1)
+            self.__addBreakPoints(
+                QModelIndex(), 0, self.breakpointModel.rowCount() - 1)
     
     def __restoreWatchpoints(self):
         """
         Private method to restore the watch expressions after a restart.
         """
         if self.debugging:
-            self.__addWatchPoints(QModelIndex(), 0, self.watchpointModel.rowCount() - 1)
+            self.__addWatchPoints(
+                QModelIndex(), 0, self.watchpointModel.rowCount() - 1)
     
     def getBreakPointModel(self):
         """
@@ -1394,7 +1456,8 @@
         """
         Public slot to get a reference to the watch expression model object.
         
-        @return reference to the watch expression model object (WatchPointModel)
+        @return reference to the watch expression model object
+            (WatchPointModel)
         """
         return self.watchpointModel
     
--- a/Debugger/DebugUI.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/DebugUI.py	Sun Oct 06 19:00:04 2013 +0200
@@ -34,13 +34,15 @@
     
     @signal clientStack(stack) emitted at breaking after a reported exception
     @signal compileForms() emitted if changed project forms should be compiled
-    @signal compileResources() emitted if changed project resources should be compiled
-    @signal debuggingStarted(filename) emitted when a debugging session was started
+    @signal compileResources() emitted if changed project resources should be
+        compiled
+    @signal debuggingStarted(filename) emitted when a debugging session was
+        started
     @signal resetUI() emitted to reset the UI
-    @signal exceptionInterrupt() emitted after the execution was interrupted by an
-        exception and acknowledged by the user
-    @signal appendStdout(msg) emitted when the client program has terminated and the
-        display of the termination dialog is suppressed
+    @signal exceptionInterrupt() emitted after the execution was interrupted
+        by an exception and acknowledged by the user
+    @signal appendStdout(msg) emitted when the client program has terminated
+        and the display of the termination dialog is suppressed
     """
     clientStack = pyqtSignal(list)
     resetUI = pyqtSignal()
@@ -76,7 +78,8 @@
         self.argvHistory = Preferences.toList(
             Preferences.Prefs.settings.value('DebugInfo/ArgumentsHistory'))
         self.wdHistory = Preferences.toList(
-            Preferences.Prefs.settings.value('DebugInfo/WorkingDirectoryHistory'))
+            Preferences.Prefs.settings.value(
+                'DebugInfo/WorkingDirectoryHistory'))
         self.envHistory = Preferences.toList(
             Preferences.Prefs.settings.value('DebugInfo/EnvironmentHistory'))
         self.excList = Preferences.toList(
@@ -84,7 +87,8 @@
         self.excIgnoreList = Preferences.toList(
             Preferences.Prefs.settings.value('DebugInfo/IgnoredExceptions'))
         self.exceptions = Preferences.toBool(
-            Preferences.Prefs.settings.value('DebugInfo/ReportExceptions', True))
+            Preferences.Prefs.settings.value(
+                'DebugInfo/ReportExceptions', True))
         self.autoClearShell = Preferences.toBool(
             Preferences.Prefs.settings.value('DebugInfo/AutoClearShell', True))
         self.tracePython = Preferences.toBool(
@@ -92,7 +96,8 @@
         self.autoContinue = Preferences.toBool(
             Preferences.Prefs.settings.value('DebugInfo/AutoContinue', True))
         self.forkAutomatically = Preferences.toBool(
-            Preferences.Prefs.settings.value('DebugInfo/ForkAutomatically', False))
+            Preferences.Prefs.settings.value(
+                'DebugInfo/ForkAutomatically', False))
         self.forkIntoChild = Preferences.toBool(
             Preferences.Prefs.settings.value('DebugInfo/ForkIntoChild', False))
         
@@ -105,8 +110,10 @@
         self.debugActions = [self.__continue, self.__step,\
                         self.__stepOver, self.__stepOut,\
                         self.__stepQuit, self.__runToCursor]
-        self.localsVarFilter, self.globalsVarFilter = Preferences.getVarFilters()
-        self.debugViewer.setVariablesFilter(self.globalsVarFilter, self.localsVarFilter)
+        self.localsVarFilter, self.globalsVarFilter = \
+            Preferences.getVarFilters()
+        self.debugViewer.setVariablesFilter(
+            self.globalsVarFilter, self.localsVarFilter)
         
         # Connect the signals emitted by the debug-server
         debugServer.clientGone.connect(self.__clientGone)
@@ -116,8 +123,10 @@
         debugServer.clientException.connect(self.__clientException)
         debugServer.clientVariables.connect(self.__clientVariables)
         debugServer.clientVariable.connect(self.__clientVariable)
-        debugServer.clientBreakConditionError.connect(self.__clientBreakConditionError)
-        debugServer.clientWatchConditionError.connect(self.__clientWatchConditionError)
+        debugServer.clientBreakConditionError.connect(
+            self.__clientBreakConditionError)
+        debugServer.clientWatchConditionError.connect(
+            self.__clientWatchConditionError)
         debugServer.passiveDebugStarted.connect(self.__passiveDebugStarted)
         debugServer.clientThreadSet.connect(self.__clientThreadSet)
         
@@ -160,12 +169,14 @@
         
         self.runAct = E5Action(self.trUtf8('Run Script'),
                 UI.PixmapCache.getIcon("runScript.png"),
-                self.trUtf8('&Run Script...'), Qt.Key_F2, 0, self, 'dbg_run_script')
+                self.trUtf8('&Run Script...'),
+                Qt.Key_F2, 0, self, 'dbg_run_script')
         self.runAct.setStatusTip(self.trUtf8('Run the current Script'))
         self.runAct.setWhatsThis(self.trUtf8(
             """<b>Run Script</b>"""
-            """<p>Set the command line arguments and run the script outside the"""
-            """ debugger. If the file has unsaved changes it may be saved first.</p>"""
+            """<p>Set the command line arguments and run the script outside"""
+            """ the debugger. If the file has unsaved changes it may be"""
+            """ saved first.</p>"""
         ))
         self.runAct.triggered[()].connect(self.__runScript)
         self.actions.append(self.runAct)
@@ -179,44 +190,47 @@
             """<b>Run Project</b>"""
             """<p>Set the command line arguments and run the current project"""
             """ outside the debugger."""
-            """ If files of the current project have unsaved changes they may"""
-            """ be saved first.</p>"""
+            """ If files of the current project have unsaved changes they"""
+            """ may be saved first.</p>"""
         ))
         self.runProjectAct.triggered[()].connect(self.__runProject)
         self.actions.append(self.runProjectAct)
 
         self.coverageAct = E5Action(self.trUtf8('Coverage run of Script'),
                 UI.PixmapCache.getIcon("coverageScript.png"),
-                self.trUtf8('Coverage run of Script...'), 0, 0, self, 'dbg_coverage_script')
+                self.trUtf8('Coverage run of Script...'), 0, 0, self,
+                'dbg_coverage_script')
         self.coverageAct.setStatusTip(
             self.trUtf8('Perform a coverage run of the current Script'))
         self.coverageAct.setWhatsThis(self.trUtf8(
             """<b>Coverage run of Script</b>"""
-            """<p>Set the command line arguments and run the script under the control"""
-            """ of a coverage analysis tool. If the file has unsaved changes it may be"""
-            """ saved first.</p>"""
+            """<p>Set the command line arguments and run the script under"""
+            """ the control of a coverage analysis tool. If the file has"""
+            """ unsaved changes it may be saved first.</p>"""
         ))
         self.coverageAct.triggered[()].connect(self.__coverageScript)
         self.actions.append(self.coverageAct)
 
-        self.coverageProjectAct = E5Action(self.trUtf8('Coverage run of Project'),
-                UI.PixmapCache.getIcon("coverageProject.png"),
-                self.trUtf8('Coverage run of Project...'), 0, 0, self, 'dbg_coverage_project')
+        self.coverageProjectAct = E5Action(
+            self.trUtf8('Coverage run of Project'),
+            UI.PixmapCache.getIcon("coverageProject.png"),
+            self.trUtf8('Coverage run of Project...'), 0, 0, self,
+            'dbg_coverage_project')
         self.coverageProjectAct.setStatusTip(
             self.trUtf8('Perform a coverage run of the current Project'))
         self.coverageProjectAct.setWhatsThis(self.trUtf8(
             """<b>Coverage run of Project</b>"""
             """<p>Set the command line arguments and run the current project"""
             """ under the control of a coverage analysis tool."""
-            """ If files of the current project have unsaved changes they may"""
-            """ be saved first.</p>"""
+            """ If files of the current project have unsaved changes"""
+            """ they may be saved first.</p>"""
         ))
         self.coverageProjectAct.triggered[()].connect(self.__coverageProject)
         self.actions.append(self.coverageProjectAct)
 
         self.profileAct = E5Action(self.trUtf8('Profile Script'),
-                UI.PixmapCache.getIcon("profileScript.png"),
-                self.trUtf8('Profile Script...'), 0, 0, self, 'dbg_profile_script')
+            UI.PixmapCache.getIcon("profileScript.png"),
+            self.trUtf8('Profile Script...'), 0, 0, self, 'dbg_profile_script')
         self.profileAct.setStatusTip(self.trUtf8('Profile the current Script'))
         self.profileAct.setWhatsThis(self.trUtf8(
             """<b>Profile Script</b>"""
@@ -227,63 +241,70 @@
         self.actions.append(self.profileAct)
 
         self.profileProjectAct = E5Action(self.trUtf8('Profile Project'),
-                UI.PixmapCache.getIcon("profileProject.png"),
-                self.trUtf8('Profile Project...'), 0, 0, self, 'dbg_profile_project')
-        self.profileProjectAct.setStatusTip(self.trUtf8('Profile the current Project'))
+            UI.PixmapCache.getIcon("profileProject.png"),
+            self.trUtf8('Profile Project...'), 0, 0, self,
+            'dbg_profile_project')
+        self.profileProjectAct.setStatusTip(
+            self.trUtf8('Profile the current Project'))
         self.profileProjectAct.setWhatsThis(self.trUtf8(
             """<b>Profile Project</b>"""
-            """<p>Set the command line arguments and profile the current project."""
-            """ If files of the current project have unsaved changes they may"""
-            """ be saved first.</p>"""
+            """<p>Set the command line arguments and profile the current"""
+            """ project. If files of the current project have unsaved"""
+            """ changes they may be saved first.</p>"""
         ))
         self.profileProjectAct.triggered[()].connect(self.__profileProject)
         self.actions.append(self.profileProjectAct)
 
         self.debugAct = E5Action(self.trUtf8('Debug Script'),
-                UI.PixmapCache.getIcon("debugScript.png"),
-                self.trUtf8('&Debug Script...'), Qt.Key_F5, 0, self, 'dbg_debug_script')
+            UI.PixmapCache.getIcon("debugScript.png"),
+            self.trUtf8('&Debug Script...'), Qt.Key_F5, 0, self,
+            'dbg_debug_script')
         self.debugAct.setStatusTip(self.trUtf8('Debug the current Script'))
         self.debugAct.setWhatsThis(self.trUtf8(
             """<b>Debug Script</b>"""
-            """<p>Set the command line arguments and set the current line to be the"""
-            """ first executable Python statement of the current editor window."""
-            """ If the file has unsaved changes it may be saved first.</p>"""
+            """<p>Set the command line arguments and set the current line"""
+            """ to be the first executable Python statement of the current"""
+            """ editor window. If the file has unsaved changes it may be"""
+            """ saved first.</p>"""
         ))
         self.debugAct.triggered[()].connect(self.__debugScript)
         self.actions.append(self.debugAct)
 
         self.debugProjectAct = E5Action(self.trUtf8('Debug Project'),
-                UI.PixmapCache.getIcon("debugProject.png"),
-                self.trUtf8('Debug &Project...'), Qt.SHIFT + Qt.Key_F5, 0, self,
-                'dbg_debug_project')
-        self.debugProjectAct.setStatusTip(self.trUtf8('Debug the current Project'))
+            UI.PixmapCache.getIcon("debugProject.png"),
+            self.trUtf8('Debug &Project...'), Qt.SHIFT + Qt.Key_F5, 0, self,
+            'dbg_debug_project')
+        self.debugProjectAct.setStatusTip(self.trUtf8(
+            'Debug the current Project'))
         self.debugProjectAct.setWhatsThis(self.trUtf8(
             """<b>Debug Project</b>"""
-            """<p>Set the command line arguments and set the current line to be the"""
-            """ first executable Python statement of the main script of the current"""
-            """ project. If files of the current project have unsaved changes they may"""
-            """ be saved first.</p>"""
+            """<p>Set the command line arguments and set the current line"""
+            """ to be the first executable Python statement of the main"""
+            """ script of the current project. If files of the current"""
+            """ project have unsaved changes they may be saved first.</p>"""
         ))
         self.debugProjectAct.triggered[()].connect(self.__debugProject)
         self.actions.append(self.debugProjectAct)
 
         self.restartAct = E5Action(self.trUtf8('Restart'),
-                UI.PixmapCache.getIcon("restart.png"),
-                self.trUtf8('Restart'), Qt.Key_F4, 0, self, 'dbg_restart_script')
-        self.restartAct.setStatusTip(self.trUtf8('Restart the last debugged script'))
+            UI.PixmapCache.getIcon("restart.png"),
+            self.trUtf8('Restart'), Qt.Key_F4, 0, self, 'dbg_restart_script')
+        self.restartAct.setStatusTip(self.trUtf8(
+            'Restart the last debugged script'))
         self.restartAct.setWhatsThis(self.trUtf8(
             """<b>Restart</b>"""
-            """<p>Set the command line arguments and set the current line to be the"""
-            """ first executable Python statement of the script that was debugged last."""
-            """ If there are unsaved changes, they may be saved first.</p>"""
+            """<p>Set the command line arguments and set the current line"""
+            """ to be the first executable Python statement of the script"""
+            """ that was debugged last. If there are unsaved changes, they"""
+            """ may be saved first.</p>"""
         ))
         self.restartAct.triggered[()].connect(self.__doRestart)
         self.actions.append(self.restartAct)
 
         self.stopAct = E5Action(self.trUtf8('Stop'),
-                UI.PixmapCache.getIcon("stopScript.png"),
-                self.trUtf8('Stop'), Qt.SHIFT + Qt.Key_F10, 0,
-                self, 'dbg_stop_script')
+            UI.PixmapCache.getIcon("stopScript.png"),
+            self.trUtf8('Stop'), Qt.SHIFT + Qt.Key_F10, 0,
+            self, 'dbg_stop_script')
         self.stopAct.setStatusTip(self.trUtf8("""Stop the running script."""))
         self.stopAct.setWhatsThis(self.trUtf8(
             """<b>Stop</b>"""
@@ -295,24 +316,26 @@
         self.debugActGrp = createActionGroup(self)
 
         act = E5Action(self.trUtf8('Continue'),
-                UI.PixmapCache.getIcon("continue.png"),
-                self.trUtf8('&Continue'), Qt.Key_F6, 0,
-                self.debugActGrp, 'dbg_continue')
+            UI.PixmapCache.getIcon("continue.png"),
+            self.trUtf8('&Continue'), Qt.Key_F6, 0,
+            self.debugActGrp, 'dbg_continue')
         act.setStatusTip(
             self.trUtf8('Continue running the program from the current line'))
         act.setWhatsThis(self.trUtf8(
             """<b>Continue</b>"""
-            """<p>Continue running the program from the current line. The program will"""
-            """ stop when it terminates or when a breakpoint is reached.</p>"""
+            """<p>Continue running the program from the current line. The"""
+            """ program will stop when it terminates or when a breakpoint"""
+            """ is reached.</p>"""
         ))
         act.triggered[()].connect(self.__continue)
         self.actions.append(act)
 
         act = E5Action(self.trUtf8('Continue to Cursor'),
-                UI.PixmapCache.getIcon("continueToCursor.png"),
-                self.trUtf8('Continue &To Cursor'), Qt.SHIFT + Qt.Key_F6, 0,
-                self.debugActGrp, 'dbg_continue_to_cursor')
-        act.setStatusTip(self.trUtf8("""Continue running the program from the"""
+            UI.PixmapCache.getIcon("continueToCursor.png"),
+            self.trUtf8('Continue &To Cursor'), Qt.SHIFT + Qt.Key_F6, 0,
+            self.debugActGrp, 'dbg_continue_to_cursor')
+        act.setStatusTip(self.trUtf8(
+            """Continue running the program from the"""
             """ current line to the current cursor position"""))
         act.setWhatsThis(self.trUtf8(
             """<b>Continue To Cursor</b>"""
@@ -323,56 +346,60 @@
         self.actions.append(act)
 
         act = E5Action(self.trUtf8('Single Step'),
-                UI.PixmapCache.getIcon("step.png"),
-                self.trUtf8('Sin&gle Step'), Qt.Key_F7, 0,
-                self.debugActGrp, 'dbg_single_step')
+            UI.PixmapCache.getIcon("step.png"),
+            self.trUtf8('Sin&gle Step'), Qt.Key_F7, 0,
+            self.debugActGrp, 'dbg_single_step')
         act.setStatusTip(self.trUtf8('Execute a single Python statement'))
         act.setWhatsThis(self.trUtf8(
             """<b>Single Step</b>"""
             """<p>Execute a single Python statement. If the statement"""
             """ is an <tt>import</tt> statement, a class constructor, or a"""
-            """ method or function call then control is returned to the debugger at"""
-            """ the next statement.</p>"""
+            """ method or function call then control is returned to the"""
+            """ debugger at the next statement.</p>"""
         ))
         act.triggered[()].connect(self.__step)
         self.actions.append(act)
 
         act = E5Action(self.trUtf8('Step Over'),
-                UI.PixmapCache.getIcon("stepOver.png"),
-                self.trUtf8('Step &Over'), Qt.Key_F8, 0,
-                self.debugActGrp, 'dbg_step_over')
-        act.setStatusTip(self.trUtf8("""Execute a single Python statement staying"""
+            UI.PixmapCache.getIcon("stepOver.png"),
+            self.trUtf8('Step &Over'), Qt.Key_F8, 0,
+            self.debugActGrp, 'dbg_step_over')
+        act.setStatusTip(self.trUtf8(
+            """Execute a single Python statement staying"""
             """ in the current frame"""))
         act.setWhatsThis(self.trUtf8(
             """<b>Step Over</b>"""
-            """<p>Execute a single Python statement staying in the same frame. If"""
-            """ the statement is an <tt>import</tt> statement, a class constructor,"""
-            """ or a method or function call then control is returned to the debugger"""
-            """ after the statement has completed.</p>"""
+            """<p>Execute a single Python statement staying in the same"""
+            """ frame. If the statement is an <tt>import</tt> statement,"""
+            """ a class constructor, or a method or function call then"""
+            """ control is returned to the debugger after the statement"""
+            """ has completed.</p>"""
         ))
         act.triggered[()].connect(self.__stepOver)
         self.actions.append(act)
 
         act = E5Action(self.trUtf8('Step Out'),
-                UI.PixmapCache.getIcon("stepOut.png"),
-                self.trUtf8('Step Ou&t'), Qt.Key_F9, 0,
-                self.debugActGrp, 'dbg_step_out')
-        act.setStatusTip(self.trUtf8("""Execute Python statements until leaving"""
+            UI.PixmapCache.getIcon("stepOut.png"),
+            self.trUtf8('Step Ou&t'), Qt.Key_F9, 0,
+            self.debugActGrp, 'dbg_step_out')
+        act.setStatusTip(self.trUtf8(
+            """Execute Python statements until leaving"""
             """ the current frame"""))
         act.setWhatsThis(self.trUtf8(
             """<b>Step Out</b>"""
-            """<p>Execute Python statements until leaving the current frame. If"""
-            """ the statements are inside an <tt>import</tt> statement, a class"""
-            """ constructor, or a method or function call then control is returned"""
-            """ to the debugger after the current frame has been left.</p>"""
+            """<p>Execute Python statements until leaving the current"""
+            """ frame. If the statements are inside an <tt>import</tt>"""
+            """ statement, a class constructor, or a method or function"""
+            """ call then control is returned to the debugger after the"""
+            """ current frame has been left.</p>"""
         ))
         act.triggered[()].connect(self.__stepOut)
         self.actions.append(act)
 
         act = E5Action(self.trUtf8('Stop'),
-                UI.PixmapCache.getIcon("stepQuit.png"),
-                self.trUtf8('&Stop'), Qt.Key_F10, 0,
-                self.debugActGrp, 'dbg_stop')
+            UI.PixmapCache.getIcon("stepQuit.png"),
+            self.trUtf8('&Stop'), Qt.Key_F10, 0,
+            self.debugActGrp, 'dbg_stop')
         act.setStatusTip(self.trUtf8('Stop debugging'))
         act.setWhatsThis(self.trUtf8(
             """<b>Stop</b>"""
@@ -384,8 +411,8 @@
         self.debugActGrp2 = createActionGroup(self)
 
         act = E5Action(self.trUtf8('Evaluate'),
-                self.trUtf8('E&valuate...'),
-                0, 0, self.debugActGrp2, 'dbg_evaluate')
+            self.trUtf8('E&valuate...'),
+            0, 0, self.debugActGrp2, 'dbg_evaluate')
         act.setStatusTip(self.trUtf8('Evaluate in current context'))
         act.setWhatsThis(self.trUtf8(
             """<b>Evaluate</b>"""
@@ -410,51 +437,59 @@
         self.actions.append(act)
         
         self.dbgFilterAct = E5Action(self.trUtf8('Variables Type Filter'),
-                self.trUtf8('Varia&bles Type Filter...'), 0, 0, self,
-                'dbg_variables_filter')
-        self.dbgFilterAct.setStatusTip(self.trUtf8('Configure variables type filter'))
+            self.trUtf8('Varia&bles Type Filter...'), 0, 0, self,
+            'dbg_variables_filter')
+        self.dbgFilterAct.setStatusTip(self.trUtf8(
+            'Configure variables type filter'))
         self.dbgFilterAct.setWhatsThis(self.trUtf8(
             """<b>Variables Type Filter</b>"""
-            """<p>Configure the variables type filter. Only variable types that are not"""
-            """ selected are displayed in the global or local variables window"""
-            """ during a debugging session.</p>"""
+            """<p>Configure the variables type filter. Only variable types"""
+            """ that are not selected are displayed in the global or local"""
+            """ variables window during a debugging session.</p>"""
         ))
-        self.dbgFilterAct.triggered[()].connect(self.__configureVariablesFilters)
+        self.dbgFilterAct.triggered[()].connect(
+            self.__configureVariablesFilters)
         self.actions.append(self.dbgFilterAct)
 
         self.excFilterAct = E5Action(self.trUtf8('Exceptions Filter'),
-                self.trUtf8('&Exceptions Filter...'), 0, 0, self, 'dbg_exceptions_filter')
-        self.excFilterAct.setStatusTip(self.trUtf8('Configure exceptions filter'))
+            self.trUtf8('&Exceptions Filter...'), 0, 0, self,
+            'dbg_exceptions_filter')
+        self.excFilterAct.setStatusTip(self.trUtf8(
+            'Configure exceptions filter'))
         self.excFilterAct.setWhatsThis(self.trUtf8(
             """<b>Exceptions Filter</b>"""
-            """<p>Configure the exceptions filter. Only exception types that are"""
-            """ listed are highlighted during a debugging session.</p>"""
-            """<p>Please note, that all unhandled exceptions are highlighted"""
-            """ indepent from the filter list.</p>"""
+            """<p>Configure the exceptions filter. Only exception types"""
+            """ that are listed are highlighted during a debugging"""
+            """ session.</p><p>Please note, that all unhandled exceptions"""
+            """ are highlighted indepent from the filter list.</p>"""
         ))
-        self.excFilterAct.triggered[()].connect(self.__configureExceptionsFilter)
+        self.excFilterAct.triggered[()].connect(
+            self.__configureExceptionsFilter)
         self.actions.append(self.excFilterAct)
         
         self.excIgnoreFilterAct = E5Action(self.trUtf8('Ignored Exceptions'),
                 self.trUtf8('&Ignored Exceptions...'), 0, 0,
                 self, 'dbg_ignored_exceptions')
-        self.excIgnoreFilterAct.setStatusTip(self.trUtf8('Configure ignored exceptions'))
+        self.excIgnoreFilterAct.setStatusTip(self.trUtf8(
+            'Configure ignored exceptions'))
         self.excIgnoreFilterAct.setWhatsThis(self.trUtf8(
             """<b>Ignored Exceptions</b>"""
-            """<p>Configure the ignored exceptions. Only exception types that are"""
-            """ not listed are highlighted during a debugging session.</p>"""
-            """<p>Please note, that unhandled exceptions cannot be ignored.</p>"""
+            """<p>Configure the ignored exceptions. Only exception types"""
+            """ that are not listed are highlighted during a debugging"""
+            """ session.</p><p>Please note, that unhandled exceptions"""
+            """ cannot be ignored.</p>"""
         ))
-        self.excIgnoreFilterAct.triggered[()].connect(self.__configureIgnoredExceptions)
+        self.excIgnoreFilterAct.triggered[()].connect(
+            self.__configureIgnoredExceptions)
         self.actions.append(self.excIgnoreFilterAct)
 
         self.dbgSetBpActGrp = createActionGroup(self)
 
         self.dbgToggleBpAct = E5Action(self.trUtf8('Toggle Breakpoint'),
-                UI.PixmapCache.getIcon("breakpointToggle.png"),
-                self.trUtf8('Toggle Breakpoint'),
-                QKeySequence(self.trUtf8("Shift+F11", "Debug|Toggle Breakpoint")), 0,
-                self.dbgSetBpActGrp, 'dbg_toggle_breakpoint')
+            UI.PixmapCache.getIcon("breakpointToggle.png"),
+            self.trUtf8('Toggle Breakpoint'),
+            QKeySequence(self.trUtf8("Shift+F11", "Debug|Toggle Breakpoint")),
+            0, self.dbgSetBpActGrp, 'dbg_toggle_breakpoint')
         self.dbgToggleBpAct.setStatusTip(self.trUtf8('Toggle Breakpoint'))
         self.dbgToggleBpAct.setWhatsThis(self.trUtf8(
             """<b>Toggle Breakpoint</b>"""
@@ -465,10 +500,10 @@
         self.actions.append(self.dbgToggleBpAct)
         
         self.dbgEditBpAct = E5Action(self.trUtf8('Edit Breakpoint'),
-                UI.PixmapCache.getIcon("cBreakpointToggle.png"),
-                self.trUtf8('Edit Breakpoint...'),
-                QKeySequence(self.trUtf8("Shift+F12", "Debug|Edit Breakpoint")), 0,
-                self.dbgSetBpActGrp, 'dbg_edit_breakpoint')
+            UI.PixmapCache.getIcon("cBreakpointToggle.png"),
+            self.trUtf8('Edit Breakpoint...'),
+            QKeySequence(self.trUtf8("Shift+F12", "Debug|Edit Breakpoint")), 0,
+            self.dbgSetBpActGrp, 'dbg_edit_breakpoint')
         self.dbgEditBpAct.setStatusTip(self.trUtf8('Edit Breakpoint'))
         self.dbgEditBpAct.setWhatsThis(self.trUtf8(
             """<b>Edit Breakpoint</b>"""
@@ -479,10 +514,11 @@
         self.actions.append(self.dbgEditBpAct)
 
         self.dbgNextBpAct = E5Action(self.trUtf8('Next Breakpoint'),
-                UI.PixmapCache.getIcon("breakpointNext.png"),
-                self.trUtf8('Next Breakpoint'),
-                QKeySequence(self.trUtf8("Ctrl+Shift+PgDown", "Debug|Next Breakpoint")), 0,
-                self.dbgSetBpActGrp, 'dbg_next_breakpoint')
+            UI.PixmapCache.getIcon("breakpointNext.png"),
+            self.trUtf8('Next Breakpoint'),
+            QKeySequence(
+                self.trUtf8("Ctrl+Shift+PgDown", "Debug|Next Breakpoint")), 0,
+            self.dbgSetBpActGrp, 'dbg_next_breakpoint')
         self.dbgNextBpAct.setStatusTip(self.trUtf8('Next Breakpoint'))
         self.dbgNextBpAct.setWhatsThis(self.trUtf8(
             """<b>Next Breakpoint</b>"""
@@ -492,10 +528,11 @@
         self.actions.append(self.dbgNextBpAct)
 
         self.dbgPrevBpAct = E5Action(self.trUtf8('Previous Breakpoint'),
-                UI.PixmapCache.getIcon("breakpointPrevious.png"),
-                self.trUtf8('Previous Breakpoint'),
-                QKeySequence(self.trUtf8("Ctrl+Shift+PgUp", "Debug|Previous Breakpoint")),
-                0, self.dbgSetBpActGrp, 'dbg_previous_breakpoint')
+            UI.PixmapCache.getIcon("breakpointPrevious.png"),
+            self.trUtf8('Previous Breakpoint'),
+            QKeySequence(
+                self.trUtf8("Ctrl+Shift+PgUp", "Debug|Previous Breakpoint")),
+            0, self.dbgSetBpActGrp, 'dbg_previous_breakpoint')
         self.dbgPrevBpAct.setStatusTip(self.trUtf8('Previous Breakpoint'))
         self.dbgPrevBpAct.setWhatsThis(self.trUtf8(
             """<b>Previous Breakpoint</b>"""
@@ -505,9 +542,10 @@
         self.actions.append(self.dbgPrevBpAct)
 
         act = E5Action(self.trUtf8('Clear Breakpoints'),
-                self.trUtf8('Clear Breakpoints'),
-                QKeySequence(self.trUtf8("Ctrl+Shift+C", "Debug|Clear Breakpoints")), 0,
-                self.dbgSetBpActGrp, 'dbg_clear_breakpoint')
+            self.trUtf8('Clear Breakpoints'),
+            QKeySequence(
+                self.trUtf8("Ctrl+Shift+C", "Debug|Clear Breakpoints")), 0,
+            self.dbgSetBpActGrp, 'dbg_clear_breakpoint')
         act.setStatusTip(self.trUtf8('Clear Breakpoints'))
         act.setWhatsThis(self.trUtf8(
             """<b>Clear Breakpoints</b>"""
@@ -578,7 +616,8 @@
         """
         Public slot to initialize the debug toolbars.
         
-        @param toolbarManager reference to a toolbar manager object (E5ToolBarManager)
+        @param toolbarManager reference to a toolbar manager object
+            (E5ToolBarManager)
         @return the generated toolbars (list of QToolBar)
         """
         starttb = QToolBar(self.trUtf8("Start"), self.ui)
@@ -612,7 +651,8 @@
         toolbarManager.addAction(self.profileAct, starttb.windowTitle())
         toolbarManager.addAction(self.profileProjectAct, starttb.windowTitle())
         toolbarManager.addAction(self.coverageAct, starttb.windowTitle())
-        toolbarManager.addAction(self.coverageProjectAct, starttb.windowTitle())
+        toolbarManager.addAction(self.coverageProjectAct,
+                                 starttb.windowTitle())
         
         return [starttb, debugtb]
         
@@ -707,8 +747,8 @@
         """
         Public slot to initialize the autoContinue flag.
         
-        @param autoContinue flag indicating, that the debugger should not stop at
-            the first executable line (boolean)
+        @param autoContinue flag indicating, that the debugger should not
+            stop at the first executable line (boolean)
         """
         self.autoContinue = autoContinue
 
@@ -855,8 +895,8 @@
         
         Preferences.Prefs.settings.setValue('DebugInfo/ArgumentsHistory',
             self.argvHistory)
-        Preferences.Prefs.settings.setValue('DebugInfo/WorkingDirectoryHistory',
-            self.wdHistory)
+        Preferences.Prefs.settings.setValue(
+            'DebugInfo/WorkingDirectoryHistory', self.wdHistory)
         Preferences.Prefs.settings.setValue('DebugInfo/EnvironmentHistory',
             self.envHistory)
         Preferences.Prefs.settings.setValue('DebugInfo/Exceptions',
@@ -949,7 +989,8 @@
                 E5MessageBox.information(self.ui, Program,
                     self.trUtf8('<p><b>{0}</b> has terminated with an exit'
                                 ' status of {1}.</p>')
-                        .format(Utilities.normabspath(self.ui.currentProg), status))
+                        .format(Utilities.normabspath(self.ui.currentProg),
+                                status))
         else:
             if self.ui.notificationsEnabled():
                 if self.ui.currentProg is None:
@@ -958,8 +999,10 @@
                 else:
                     msg = self.trUtf8('"{0}" has terminated with an exit'
                                       ' status of {1}.')\
-                            .format(os.path.basename(self.ui.currentProg), status)
-                self.ui.showNotification(UI.PixmapCache.getPixmap("debug48.png"),
+                            .format(os.path.basename(self.ui.currentProg),
+                                    status)
+                self.ui.showNotification(
+                    UI.PixmapCache.getPixmap("debug48.png"),
                     self.trUtf8("Program terminated"), msg)
             else:
                 if self.ui.currentProg is None:
@@ -970,16 +1013,19 @@
                     self.appendStdout.emit(
                         self.trUtf8('"{0}" has terminated with an exit'
                                     ' status of {1}.\n')
-                            .format(Utilities.normabspath(self.ui.currentProg), status))
+                            .format(Utilities.normabspath(self.ui.currentProg),
+                                    status))
 
     def __clientSyntaxError(self, message, filename, lineNo, characterNo):
         """
         Private method to handle a syntax error in the debugged program.
         
         @param message message of the syntax error (string)
-        @param filename translated filename of the syntax error position (string)
+        @param filename translated filename of the syntax error position
+            (string)
         @param lineNo line number of the syntax error position (integer)
-        @param characterNo character number of the syntax error position (integer)
+        @param characterNo character number of the syntax error position
+            (integer)
         """
         self.__resetUI()
         self.ui.raise_()
@@ -987,21 +1033,26 @@
         
         if message is None:
             E5MessageBox.critical(self.ui, Program,
-                self.trUtf8('The program being debugged contains an unspecified'
-                            ' syntax error.'))
+                self.trUtf8(
+                    'The program being debugged contains an unspecified'
+                    ' syntax error.'))
             return
             
         if not os.path.isabs(filename):
-            if os.path.exists(os.path.join(self.project.getProjectPath(), filename)):
-                filename = os.path.join(self.project.getProjectPath(), filename)
+            if os.path.exists(os.path.join(self.project.getProjectPath(),
+                              filename)):
+                filename = os.path.join(self.project.getProjectPath(),
+                                        filename)
             else:
-                d = os.path.dirname(self.project.getMainScript(normalized=True))
+                d = os.path.dirname(
+                    self.project.getMainScript(normalized=True))
                 if os.path.exists(os.path.join(d, filename)):
                     filename = os.path.join(d, filename)
         self.viewmanager.setFileLine(filename, lineNo, True, True)
         E5MessageBox.critical(self.ui, Program,
             self.trUtf8('<p>The file <b>{0}</b> contains the syntax error'
-                        ' <b>{1}</b> at line <b>{2}</b>, character <b>{3}</b>.</p>')
+                        ' <b>{1}</b> at line <b>{2}</b>, character <b>{3}</b>.'
+                        '</p>')
                 .format(filename, message, lineNo, characterNo))
         
     def __clientException(self, exceptionType, exceptionMessage, stackTrace):
@@ -1039,7 +1090,8 @@
                 except (UnicodeError, IOError):
                     pass
                 if res != E5MessageBox.No:
-                    self.viewmanager.setFileLine(stackTrace[0][0], stackTrace[0][1], True)
+                    self.viewmanager.setFileLine(
+                        stackTrace[0][0], stackTrace[0][1], True)
             if res != E5MessageBox.No:
                 if Preferences.getDebugger("BreakAlways"):
                     res = E5MessageBox.Yes
@@ -1055,21 +1107,26 @@
                                 E5MessageBox.Yes | \
                                 E5MessageBox.Ignore)
                         res = E5MessageBox.critical(self.ui, Program,
-                            self.trUtf8('<p>The debugged program raised the exception'
-                                        ' <b>{0}</b><br>"<b>{1}</b>"<br>File: <b>{2}</b>,'
-                                        ' Line: <b>{3}</b></p><p>Break here?</p>')
-                                .format(exceptionType,
-                                        Utilities.html_encode(exceptionMessage),
-                                        stackTrace[0][0],
-                                        stackTrace[0][1]),
+                            self.trUtf8(
+                                '<p>The debugged program raised the exception'
+                                ' <b>{0}</b><br>"<b>{1}</b>"<br>'
+                                'File: <b>{2}</b>, Line: <b>{3}</b></p>'
+                                '<p>Break here?</p>')
+                                .format(
+                                    exceptionType,
+                                    Utilities.html_encode(exceptionMessage),
+                                    stackTrace[0][0],
+                                    stackTrace[0][1]),
                             buttons,
                             E5MessageBox.No)
                     else:
                         res = E5MessageBox.critical(self.ui, Program,
-                            self.trUtf8('<p>The debugged program raised the exception'
-                                        ' <b>{0}</b><br>"<b>{1}</b>"</p>')
-                                .format(exceptionType,
-                                        Utilities.html_encode(exceptionMessage)))
+                            self.trUtf8(
+                                '<p>The debugged program raised the exception'
+                                ' <b>{0}</b><br>"<b>{1}</b>"</p>')
+                                .format(
+                                    exceptionType,
+                                    Utilities.html_encode(exceptionMessage)))
             if res == E5MessageBox.Yes:
                 self.exceptionInterrupt.emit()
                 stack = []
@@ -1100,7 +1157,8 @@
         self.__resetUI()
         if unplanned:
             E5MessageBox.information(self.ui, Program,
-                self.trUtf8('The program being debugged has terminated unexpectedly.'))
+                self.trUtf8('The program being debugged has terminated'
+                            ' unexpectedly.'))
         
     def __getThreadList(self):
         """
@@ -1130,7 +1188,8 @@
         """
         Private method to write the clients variables to the user interface.
         
-        @param scope scope of the variables (-1 = empty global, 1 = global, 0 = local)
+        @param scope scope of the variables (-1 = empty global, 1 = global,
+            0 = local)
         @param variables the list of variables from the client
         """
         if scope > 0:
@@ -1150,10 +1209,11 @@
         
     def __clientVariable(self, scope, variables):
         """
-        Private method to write the contents of a clients classvariable to the user
-        interface.
+        Private method to write the contents of a clients classvariable to
+        the user interface.
         
-        @param scope scope of the variables (-1 = empty global, 1 = global, 0 = local)
+        @param scope scope of the variables (-1 = empty global, 1 = global,
+            0 = local)
         @param variables the list of members of a classvariable from the client
         """
         if scope == 1:
@@ -1170,9 +1230,10 @@
         """
         E5MessageBox.critical(self.ui,
             self.trUtf8("Breakpoint Condition Error"),
-            self.trUtf8("""<p>The condition of the breakpoint <b>{0}, {1}</b>"""
-                        """ contains a syntax error.</p>""")\
-                        .format(filename, lineno))
+            self.trUtf8(
+                """<p>The condition of the breakpoint <b>{0}, {1}</b>"""
+                """ contains a syntax error.</p>""")\
+                .format(filename, lineno))
         
         model = self.debugServer.getBreakPointModel()
         index = model.getBreakPointIndex(filename, lineno)
@@ -1190,7 +1251,8 @@
             [], self.ui, modal=True)
         if dlg.exec_() == QDialog.Accepted:
             cond, temp, enabled, count = dlg.getData()
-            model.setBreakPointByIndex(index, fn, line, (cond, temp, enabled, count))
+            model.setBreakPointByIndex(index, fn, line,
+                                       (cond, temp, enabled, count))
         
     def __clientWatchConditionError(self, cond):
         """
@@ -1225,7 +1287,8 @@
             
             # check for duplicates
             idx = self.__model.getWatchPointIndex(cond, special)
-            duplicate = idx.isValid() and idx.internalPointer() != index.internalPointer()
+            duplicate = idx.isValid() and \
+                idx.internalPointer() != index.internalPointer()
             if duplicate:
                 if not special:
                     msg = self.trUtf8("""<p>A watch expression '<b>{0}</b>'"""
@@ -1233,7 +1296,8 @@
                             .format(Utilities.html_encode(cond))
                 else:
                     msg = self.trUtf8("""<p>A watch expression '<b>{0}</b>'"""
-                                """ for the variable <b>{1}</b> already exists.</p>""")\
+                                """ for the variable <b>{1}</b> already"""
+                                """ exists.</p>""")\
                             .format(special,
                                     Utilities.html_encode(cond))
                 E5MessageBox.warning(self,
@@ -1373,8 +1437,8 @@
         """
         Private method to handle the coverage actions.
         
-        @param runProject flag indicating coverage of the current project (True)
-                or script (false)
+        @param runProject flag indicating coverage of the current project
+            (True) or script (false)
         """
         from .StartDialog import StartDialog
         
@@ -1387,10 +1451,12 @@
             cap = self.trUtf8("Coverage of Project")
         else:
             cap = self.trUtf8("Coverage of Script")
-        dlg = StartDialog(cap, self.argvHistory, self.wdHistory, self.envHistory,
-            self.exceptions, self.ui, 2, autoClearShell=self.autoClearShell)
+        dlg = StartDialog(cap, self.argvHistory, self.wdHistory,
+            self.envHistory, self.exceptions, self.ui, 2,
+            autoClearShell=self.autoClearShell)
         if dlg.exec_() == QDialog.Accepted:
-            argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
+            argv, wd, env, exceptions, clearShell, clearHistories, console = \
+                dlg.getData()
             eraseCoverage = dlg.getCoverageData()
             
             if runProject:
@@ -1407,7 +1473,8 @@
                     doNotStart = True
                 
                 # save the info for later use
-                self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
+                self.project.setDbgInfo(
+                    argv, wd, env, exceptions, self.excList,
                     self.excIgnoreList, clearShell)
                 
                 self.lastStartAction = 6
@@ -1483,8 +1550,8 @@
         """
         Private method to handle the profile actions.
         
-        @param runProject flag indicating profiling of the current project (True)
-                or script (False)
+        @param runProject flag indicating profiling of the current project
+            (True) or script (False)
         """
         from .StartDialog import StartDialog
         
@@ -1497,11 +1564,13 @@
             cap = self.trUtf8("Profile of Project")
         else:
             cap = self.trUtf8("Profile of Script")
-        dlg = StartDialog(cap, self.argvHistory, self.wdHistory, self.envHistory,
+        dlg = StartDialog(
+            cap, self.argvHistory, self.wdHistory, self.envHistory,
             self.exceptions, self.ui, 3,
             autoClearShell=self.autoClearShell)
         if dlg.exec_() == QDialog.Accepted:
-            argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
+            argv, wd, env, exceptions, clearShell, clearHistories, console = \
+                dlg.getData()
             eraseTimings = dlg.getProfilingData()
             
             if runProject:
@@ -1518,7 +1587,8 @@
                     doNotStart = True
                 
                 # save the info for later use
-                self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
+                self.project.setDbgInfo(
+                    argv, wd, env, exceptions, self.excList,
                     self.excIgnoreList, clearShell)
                 
                 self.lastStartAction = 8
@@ -1608,13 +1678,15 @@
             cap = self.trUtf8("Run Project")
         else:
             cap = self.trUtf8("Run Script")
-        dlg = StartDialog(cap, self.argvHistory, self.wdHistory, self.envHistory,
+        dlg = StartDialog(
+            cap, self.argvHistory, self.wdHistory, self.envHistory,
             self.exceptions, self.ui, 1,
             autoClearShell=self.autoClearShell,
             autoFork=self.forkAutomatically,
             forkChild=self.forkIntoChild)
         if dlg.exec_() == QDialog.Accepted:
-            argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
+            argv, wd, env, exceptions, clearShell, clearHistories, console = \
+                dlg.getData()
             forkAutomatically, forkIntoChild = dlg.getRunData()
             
             if runProject:
@@ -1631,7 +1703,8 @@
                     doNotStart = True
                 
                 # save the info for later use
-                self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
+                self.project.setDbgInfo(
+                    argv, wd, env, exceptions, self.excList,
                     self.excIgnoreList, clearShell)
                 
                 self.lastStartAction = 4
@@ -1708,8 +1781,8 @@
         """
         Private method to handle the debug actions.
         
-        @param debugProject flag indicating debugging the current project (True)
-                or script (False)
+        @param debugProject flag indicating debugging the current project
+            (True) or script (False)
         """
         from .StartDialog import StartDialog
         
@@ -1722,12 +1795,14 @@
             cap = self.trUtf8("Debug Project")
         else:
             cap = self.trUtf8("Debug Script")
-        dlg = StartDialog(cap, self.argvHistory, self.wdHistory, self.envHistory,
+        dlg = StartDialog(
+            cap, self.argvHistory, self.wdHistory, self.envHistory,
             self.exceptions, self.ui, 0, tracePython=self.tracePython,
             autoClearShell=self.autoClearShell, autoContinue=self.autoContinue,
             autoFork=self.forkAutomatically, forkChild=self.forkIntoChild)
         if dlg.exec_() == QDialog.Accepted:
-            argv, wd, env, exceptions, clearShell, clearHistories, console = dlg.getData()
+            argv, wd, env, exceptions, clearShell, clearHistories, console = \
+                dlg.getData()
             tracePython, autoContinue, forkAutomatically, forkIntoChild = \
                 dlg.getDebugData()
             
@@ -1745,7 +1820,8 @@
                     doNotStart = True
                 
                 # save the info for later use
-                self.project.setDbgInfo(argv, wd, env, exceptions, self.excList,
+                self.project.setDbgInfo(
+                    argv, wd, env, exceptions, self.excList,
                     self.excIgnoreList, clearShell, tracePython=tracePython,
                     autoContinue=self.autoContinue)
                 
@@ -1798,7 +1874,8 @@
             self.viewmanager.unhighlight()
             
             if not doNotStart:
-                if debugProject and self.project.getProjectType() == "E4Plugin":
+                if debugProject and \
+                        self.project.getProjectType() == "E4Plugin":
                     argv = '--plugin="{0}" {1}'.format(fn, argv)
                     fn = os.path.join(getConfig('ericDir'), "eric5.py")
                     tracePython = True  # override flag because it must be true
@@ -1812,7 +1889,8 @@
                 
                 # Ask the client to open the new program.
                 self.debugServer.remoteLoad(fn, argv, wd, env,
-                    autoClearShell=self.autoClearShell, tracePython=tracePython,
+                    autoClearShell=self.autoClearShell,
+                    tracePython=tracePython,
                     autoContinue=autoContinue, forProject=debugProject,
                     runInConsole=console, autoFork=forkAutomatically,
                     forkChild=forkIntoChild, clientType=self.clientType,
@@ -1825,7 +1903,8 @@
         
     def __doRestart(self):
         """
-        Private slot to handle the restart action to restart the last debugged file.
+        Private slot to handle the restart action to restart the last
+        debugged file.
         """
         self.__resetUI()
         doNotStart = False
@@ -1870,11 +1949,16 @@
                 self.debugViewer.setCallTraceToProjectMode(forProject)
                 
                 # Ask the client to debug the new program.
-                self.debugServer.remoteLoad(fn, argv, wd, env,
-                    autoClearShell=self.autoClearShell, tracePython=self.tracePython,
-                    autoContinue=self.autoContinue, forProject=forProject,
-                    runInConsole=self.runInConsole, autoFork=self.forkAutomatically,
-                    forkChild=self.forkIntoChild, clientType=self.clientType,
+                self.debugServer.remoteLoad(
+                    fn, argv, wd, env,
+                    autoClearShell=self.autoClearShell,
+                    tracePython=self.tracePython,
+                    autoContinue=self.autoContinue,
+                    forProject=forProject,
+                    runInConsole=self.runInConsole,
+                    autoFork=self.forkAutomatically,
+                    forkChild=self.forkIntoChild,
+                    clientType=self.clientType,
                     enableCallTrace=enableCallTrace)
                 
                 # Signal that we have started a debugging session
@@ -1882,23 +1966,33 @@
             
             elif self.lastStartAction in [3, 4]:
                 # Ask the client to run the new program.
-                self.debugServer.remoteRun(fn, argv, wd, env,
-                    autoClearShell=self.autoClearShell, forProject=forProject,
-                    runInConsole=self.runInConsole, autoFork=self.forkAutomatically,
-                    forkChild=self.forkIntoChild, clientType=self.clientType)
+                self.debugServer.remoteRun(
+                    fn, argv, wd, env,
+                    autoClearShell=self.autoClearShell,
+                    forProject=forProject,
+                    runInConsole=self.runInConsole,
+                    autoFork=self.forkAutomatically,
+                    forkChild=self.forkIntoChild,
+                    clientType=self.clientType)
             
             elif self.lastStartAction in [5, 6]:
                 # Ask the client to coverage run the new program.
-                self.debugServer.remoteCoverage(fn, argv, wd, env,
-                    autoClearShell=self.autoClearShell, erase=self.eraseCoverage,
-                    forProject=forProject, runInConsole=self.runInConsole,
+                self.debugServer.remoteCoverage(
+                    fn, argv, wd, env,
+                    autoClearShell=self.autoClearShell,
+                    erase=self.eraseCoverage,
+                    forProject=forProject,
+                    runInConsole=self.runInConsole,
                     clientType=self.clientType)
             
             elif self.lastStartAction in [7, 8]:
                 # Ask the client to profile run the new program.
-                self.debugServer.remoteProfile(fn, argv, wd, env,
-                    autoClearShell=self.autoClearShell, erase=self.eraseTimings,
-                    forProject=forProject, runInConsole=self.runInConsole,
+                self.debugServer.remoteProfile(
+                    fn, argv, wd, env,
+                    autoClearShell=self.autoClearShell,
+                    erase=self.eraseTimings,
+                    forProject=forProject,
+                    runInConsole=self.runInConsole,
                     clientType=self.clientType)
             
             self.stopAct.setEnabled(True)
--- a/Debugger/DebugViewer.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/DebugViewer.py	Sun Oct 06 19:00:04 2013 +0200
@@ -23,8 +23,9 @@
 import os
 
 from PyQt4.QtCore import pyqtSignal
-from PyQt4.QtGui import QWidget, QVBoxLayout, QHBoxLayout, QLineEdit, QSizePolicy, \
-    QPushButton, QComboBox, QLabel, QTreeWidget, QTreeWidgetItem, QHeaderView
+from PyQt4.QtGui import QWidget, QVBoxLayout, QHBoxLayout, QLineEdit, \
+    QSizePolicy, QPushButton, QComboBox, QLabel, QTreeWidget, \
+    QTreeWidgetItem, QHeaderView
 
 import UI.PixmapCache
 import Preferences
@@ -37,9 +38,9 @@
     Class implementing a widget conatining various debug related views.
     
     The individual tabs contain the interpreter shell (optional),
-    the filesystem browser (optional), the two variables viewers (global and local),
-    a breakpoint viewer, a watch expression viewer and the exception logger. Additionally
-    a list of all threads is shown.
+    the filesystem browser (optional), the two variables viewers
+    (global and local), a breakpoint viewer, a watch expression viewer and
+    the exception logger. Additionally a list of all threads is shown.
     
     @signal sourceFile(string, int) emitted to open a source file at a line
     """
@@ -54,13 +55,13 @@
         @param docked flag indicating a dock window
         @param vm reference to the viewmanager object
         @param parent parent widget (QWidget)
-        @param embeddedShell flag indicating whether the shell should be included.
-                This flag is set to False by those layouts, that have the interpreter
-                shell in a separate window.
+        @param embeddedShell flag indicating whether the shell should be
+            included. This flag is set to False by those layouts, that have
+            the interpreter shell in a separate window.
         @param embeddedBrowser flag indicating whether the file browser should
-                be included. This flag is set to False by those layouts, that
-                have the file browser in a separate window or embedded
-                in the project browser instead.
+            be included. This flag is set to False by those layouts, that
+            have the file browser in a separate window or embedded
+            in the project browser instead.
         """
         super().__init__(parent)
         
@@ -110,17 +111,20 @@
         self.glvWidgetHLayout.setContentsMargins(3, 3, 3, 3)
         
         self.globalsFilterEdit = QLineEdit(self.glvWidget)
-        self.globalsFilterEdit.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        self.globalsFilterEdit.setSizePolicy(
+            QSizePolicy.Expanding, QSizePolicy.Fixed)
         self.glvWidgetHLayout.addWidget(self.globalsFilterEdit)
         self.globalsFilterEdit.setToolTip(
-            self.trUtf8("Enter regular expression patterns separated by ';' to define "
-                "variable filters. "))
+            self.trUtf8("Enter regular expression patterns separated by ';'"
+                        " to define variable filters. "))
         self.globalsFilterEdit.setWhatsThis(
-            self.trUtf8("Enter regular expression patterns separated by ';' to define "
-                "variable filters. All variables and class attributes matched by one of "
-                "the expressions are not shown in the list above."))
+            self.trUtf8("Enter regular expression patterns separated by ';'"
+                        " to define variable filters. All variables and"
+                        " class attributes matched by one of the expressions"
+                        " are not shown in the list above."))
         
-        self.setGlobalsFilterButton = QPushButton(self.trUtf8('Set'), self.glvWidget)
+        self.setGlobalsFilterButton = QPushButton(
+            self.trUtf8('Set'), self.glvWidget)
         self.glvWidgetHLayout.addWidget(self.setGlobalsFilterButton)
         self.glvWidgetVLayout.addLayout(self.glvWidgetHLayout)
         
@@ -128,7 +132,8 @@
             UI.PixmapCache.getIcon("globalVariables.png"), '')
         self.__tabWidget.setTabToolTip(index, self.globalsViewer.windowTitle())
         
-        self.setGlobalsFilterButton.clicked[()].connect(self.__setGlobalsFilter)
+        self.setGlobalsFilterButton.clicked[()].connect(
+            self.__setGlobalsFilter)
         self.globalsFilterEdit.returnPressed.connect(self.__setGlobalsFilter)
         
         # add the local variables viewer
@@ -142,7 +147,8 @@
         self.lvWidgetHLayout1.setContentsMargins(3, 3, 3, 3)
         
         self.stackComboBox = QComboBox(self.lvWidget)
-        self.stackComboBox.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        self.stackComboBox.setSizePolicy(
+            QSizePolicy.Expanding, QSizePolicy.Fixed)
         self.lvWidgetHLayout1.addWidget(self.stackComboBox)
 
         self.sourceButton = QPushButton(self.trUtf8('Source'), self.lvWidget)
@@ -157,17 +163,21 @@
         self.lvWidgetHLayout2.setContentsMargins(3, 3, 3, 3)
         
         self.localsFilterEdit = QLineEdit(self.lvWidget)
-        self.localsFilterEdit.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
+        self.localsFilterEdit.setSizePolicy(
+            QSizePolicy.Expanding, QSizePolicy.Fixed)
         self.lvWidgetHLayout2.addWidget(self.localsFilterEdit)
         self.localsFilterEdit.setToolTip(
-            self.trUtf8("Enter regular expression patterns separated by ';' to define "
+            self.trUtf8(
+                "Enter regular expression patterns separated by ';' to define "
                 "variable filters. "))
         self.localsFilterEdit.setWhatsThis(
-            self.trUtf8("Enter regular expression patterns separated by ';' to define "
-                "variable filters. All variables and class attributes matched by one of "
-                "the expressions are not shown in the list above."))
+            self.trUtf8(
+                "Enter regular expression patterns separated by ';' to define "
+                "variable filters. All variables and class attributes matched"
+                " by one of the expressions are not shown in the list above."))
         
-        self.setLocalsFilterButton = QPushButton(self.trUtf8('Set'), self.lvWidget)
+        self.setLocalsFilterButton = QPushButton(
+            self.trUtf8('Set'), self.lvWidget)
         self.lvWidgetHLayout2.addWidget(self.setLocalsFilterButton)
         self.lvWidgetVLayout.addLayout(self.lvWidgetHLayout2)
         
@@ -176,7 +186,8 @@
         self.__tabWidget.setTabToolTip(index, self.localsViewer.windowTitle())
         
         self.sourceButton.clicked[()].connect(self.__showSource)
-        self.stackComboBox.currentIndexChanged[int].connect(self.__frameSelected)
+        self.stackComboBox.currentIndexChanged[int].connect(
+            self.__frameSelected)
         self.setLocalsFilterButton.clicked[()].connect(self.__setLocalsFilter)
         self.localsFilterEdit.returnPressed.connect(self.__setLocalsFilter)
         
@@ -185,16 +196,19 @@
         self.callStackViewer = CallStackViewer(self.debugServer)
         index = self.__tabWidget.addTab(self.callStackViewer,
             UI.PixmapCache.getIcon("step.png"), "")
-        self.__tabWidget.setTabToolTip(index, self.callStackViewer.windowTitle())
+        self.__tabWidget.setTabToolTip(
+            index, self.callStackViewer.windowTitle())
         self.callStackViewer.sourceFile.connect(self.sourceFile)
-        self.callStackViewer.frameSelected.connect(self.__callStackFrameSelected)
+        self.callStackViewer.frameSelected.connect(
+            self.__callStackFrameSelected)
         
         from .CallTraceViewer import CallTraceViewer
         # add the call trace viewer
         self.callTraceViewer = CallTraceViewer(self.debugServer)
         index = self.__tabWidget.addTab(self.callTraceViewer,
             UI.PixmapCache.getIcon("callTrace.png"), "")
-        self.__tabWidget.setTabToolTip(index, self.callTraceViewer.windowTitle())
+        self.__tabWidget.setTabToolTip(
+            index, self.callTraceViewer.windowTitle())
         self.callTraceViewer.sourceFile.connect(self.sourceFile)
         
         from .BreakPointViewer import BreakPointViewer
@@ -203,7 +217,8 @@
         self.breakpointViewer.setModel(self.debugServer.getBreakPointModel())
         index = self.__tabWidget.addTab(self.breakpointViewer,
             UI.PixmapCache.getIcon("breakpoints.png"), '')
-        self.__tabWidget.setTabToolTip(index, self.breakpointViewer.windowTitle())
+        self.__tabWidget.setTabToolTip(
+            index, self.breakpointViewer.windowTitle())
         self.breakpointViewer.sourceFile.connect(self.sourceFile)
         
         from .WatchPointViewer import WatchPointViewer
@@ -212,14 +227,16 @@
         self.watchpointViewer.setModel(self.debugServer.getWatchPointModel())
         index = self.__tabWidget.addTab(self.watchpointViewer,
             UI.PixmapCache.getIcon("watchpoints.png"), '')
-        self.__tabWidget.setTabToolTip(index, self.watchpointViewer.windowTitle())
+        self.__tabWidget.setTabToolTip(
+            index, self.watchpointViewer.windowTitle())
         
         from .ExceptionLogger import ExceptionLogger
         # add the exception logger
         self.exceptionLogger = ExceptionLogger()
         index = self.__tabWidget.addTab(self.exceptionLogger,
             UI.PixmapCache.getIcon("exceptions.png"), '')
-        self.__tabWidget.setTabToolTip(index, self.exceptionLogger.windowTitle())
+        self.__tabWidget.setTabToolTip(
+            index, self.exceptionLogger.windowTitle())
         
         if self.embeddedShell:
             self.__tabWidget.setCurrentWidget(self.shellAssembly)
@@ -232,8 +249,9 @@
         # add the threads viewer
         self.__mainLayout.addWidget(QLabel(self.trUtf8("Threads:")))
         self.__threadList = QTreeWidget()
-        self.__threadList.setHeaderLabels([self.trUtf8("ID"), self.trUtf8("Name"),
-                                           self.trUtf8("State"), ""])
+        self.__threadList.setHeaderLabels(
+            [self.trUtf8("ID"), self.trUtf8("Name"),
+             self.trUtf8("State"), ""])
         self.__threadList.setSortingEnabled(True)
         self.__mainLayout.addWidget(self.__threadList)
         
@@ -383,8 +401,8 @@
         """
         Public slot to show the call stack of the program being debugged.
         
-        @param stack list of tuples with call stack data (file name, line number,
-            function name, formatted argument/values list)
+        @param stack list of tuples with call stack data (file name,
+            line number, function name, formatted argument/values list)
         """
         block = self.stackComboBox.blockSignals(True)
         self.framenr = 0
@@ -401,7 +419,8 @@
         """
         Public slot to set the local variables filter.
         
-        @param globalsFilter filter list for global variable types (list of int)
+        @param globalsFilter filter list for global variable types
+            (list of int)
         @param localsFilter filter list for local variable types (list of int)
         """
         self.globalsFilter = globalsFilter
@@ -409,7 +428,8 @@
         
     def __showSource(self):
         """
-        Private slot to handle the source button press to show the selected file.
+        Private slot to handle the source button press to show the selected
+        file.
         """
         index = self.stackComboBox.currentIndex()
         if index > -1 and self.currentStack:
@@ -444,7 +464,8 @@
         filter = self.localsFilterEdit.text()
         self.debugServer.remoteClientSetFilter(0, filter)
         if self.currentStack:
-            self.debugServer.remoteClientVariables(0, self.localsFilter, self.framenr)
+            self.debugServer.remoteClientVariables(
+                0, self.localsFilter, self.framenr)
         
     def handleDebuggingStarted(self):
         """
@@ -488,7 +509,8 @@
             else:
                 state = self.trUtf8("running")
             itm = QTreeWidgetItem(self.__threadList,
-                                  ["{0:d}".format(thread['id']), thread['name'], state])
+                                  ["{0:d}".format(thread['id']),
+                                   thread['name'], state])
             if thread['id'] == currentID:
                 citm = itm
         
@@ -505,7 +527,8 @@
         Private slot to handle the selection of a thread in the thread list.
         
         @param current reference to the new current item (QTreeWidgetItem)
-        @param previous reference to the previous current item (QTreeWidgetItem)
+        @param previous reference to the previous current item
+            (QTreeWidgetItem)
         """
         if current is not None and self.__doThreadListUpdate:
             tid = int(current.text(0))
--- a/Debugger/DebuggerInterfaceNone.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/DebuggerInterfaceNone.py	Sun Oct 06 19:00:04 2013 +0200
@@ -119,20 +119,21 @@
         """
         return
         
-    def remoteLoad(self, fn, argv, wd, traceInterpreter=False, autoContinue=True,
-                   autoFork=False, forkChild=False):
+    def remoteLoad(self, fn, argv, wd, traceInterpreter=False,
+                   autoContinue=True, autoFork=False, forkChild=False):
         """
         Public method to load a new program to debug.
         
         @param fn the filename to debug (string)
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
-        @keyparam traceInterpreter flag indicating if the interpreter library should be
-            traced as well (boolean)
-        @keyparam autoContinue flag indicating, that the debugger should not stop
-            at the first executable line (boolean)
+        @keyparam traceInterpreter flag indicating if the interpreter library
+            should be traced as well (boolean)
+        @keyparam autoContinue flag indicating, that the debugger should not
+            stop at the first executable line (boolean)
         @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking (boolean)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
         """
         return
         
@@ -144,7 +145,8 @@
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
         @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking (boolean)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
         """
         return
         
@@ -167,7 +169,8 @@
         @param fn the filename to run (string)
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
-        @keyparam erase flag indicating that timing info should be cleared first (boolean)
+        @keyparam erase flag indicating that timing info should be cleared
+            first (boolean)
         """
         return
 
@@ -231,7 +234,8 @@
         
         @param fn filename the breakpoint belongs to (string)
         @param line linenumber of the breakpoint (int)
-        @param enable flag indicating enabling or disabling a breakpoint (boolean)
+        @param enable flag indicating enabling or disabling a breakpoint
+            (boolean)
         """
         return
         
@@ -250,7 +254,8 @@
         Public method to set or clear a watch expression.
         
         @param cond expression of the watch expression (string)
-        @param set flag indicating setting or resetting a watch expression (boolean)
+        @param set flag indicating setting or resetting a watch expression
+            (boolean)
         @param temp flag indicating a temporary watch expression (boolean)
         """
         return
@@ -260,13 +265,15 @@
         Public method to enable or disable a watch expression.
         
         @param cond expression of the watch expression (string)
-        @param enable flag indicating enabling or disabling a watch expression (boolean)
+        @param enable flag indicating enabling or disabling a watch
+            expression (boolean)
         """
         return
     
     def remoteWatchpointIgnore(self, cond, count):
         """
-        Public method to ignore a watch expression the next couple of occurrences.
+        Public method to ignore a watch expression the next couple of
+        occurrences.
         
         @param cond expression of the watch expression (string)
         @param count number of occurrences to ignore (int)
@@ -335,7 +342,8 @@
     
     def remoteEval(self, arg):
         """
-        Public method to evaluate arg in the current context of the debugged program.
+        Public method to evaluate arg in the current context of the debugged
+        program.
         
         @param arg the arguments to evaluate (string)
         """
@@ -343,7 +351,8 @@
         
     def remoteExec(self, stmt):
         """
-        Public method to execute stmt in the current context of the debugged program.
+        Public method to execute stmt in the current context of the debugged
+        program.
         
         @param stmt statement to execute (string)
         """
@@ -379,11 +388,13 @@
         @param tn the testname to load (string)
         @param tfn the test function name to load tests from (string)
         @param failed list of failed test, if only failed test should be run
-                (list of strings)
-        @param cov flag indicating collection of coverage data is requested (boolean)
+            (list of strings)
+        @param cov flag indicating collection of coverage data is requested
+            (boolean)
         @param covname filename to be used to assemble the coverage caches
-                filename (string)
-        @param coverase flag indicating erasure of coverage data is requested (boolean)
+            filename (string)
+        @param coverase flag indicating erasure of coverage data is requested
+            (boolean)
         """
         return
         
--- a/Debugger/DebuggerInterfacePython.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/DebuggerInterfacePython.py	Sun Oct 06 19:00:04 2013 +0200
@@ -74,7 +74,8 @@
         # set default values for capabilities of clients
         self.clientCapabilities = ClientDefaultCapabilities
         
-        self.codec = QTextCodec.codecForName(Preferences.getSystem("StringEncoding"))
+        self.codec = QTextCodec.codecForName(
+            Preferences.getSystem("StringEncoding"))
         
         self.__unicodeRe = re.compile(r"""\bu(["'])""")
         
@@ -123,7 +124,8 @@
         
         @param program name of the executable to start (string)
         @param arguments arguments to be passed to the program (list of string)
-        @param environment dictionary of environment settings to pass (dict of string)
+        @param environment dictionary of environment settings to pass
+            (dict of string)
         @return the process object (QProcess) or None
         """
         proc = QProcess()
@@ -162,19 +164,22 @@
         debugClientType = Preferences.getDebugger("DebugClientType")
         if debugClientType == "standard":
             debugClient = os.path.join(getConfig('ericDir'),
-                                       "DebugClients", "Python", "DebugClient.py")
+                                       "DebugClients", "Python",
+                                       "DebugClient.py")
         elif debugClientType == "threaded":
             debugClient = os.path.join(getConfig('ericDir'),
-                                       "DebugClients", "Python", "DebugClientThreads.py")
+                                       "DebugClients", "Python",
+                                       "DebugClientThreads.py")
         else:
             debugClient = Preferences.getDebugger("DebugClient")
             if debugClient == "":
                 debugClient = os.path.join(sys.path[0],
-                                           "DebugClients", "Python", "DebugClient.py")
+                                           "DebugClients", "Python",
+                                           "DebugClient.py")
         
         redirect = str(Preferences.getDebugger("PythonRedirect"))
-        noencoding = \
-            Preferences.getDebugger("PythonNoEncoding") and '--no-encoding' or ''
+        noencoding = Preferences.getDebugger("PythonNoEncoding") and \
+            '--no-encoding' or ''
         
         if Preferences.getDebugger("RemoteDbgEnabled"):
             ipaddr = self.debugServer.getHostAddress(False)
@@ -192,7 +197,8 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 
                 # set translation function
                 if Preferences.getDebugger("PathTranslation"):
@@ -237,7 +243,8 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 return process, self.__isNetworked
         
         process = self.__startProcess(interpreter,
@@ -246,7 +253,8 @@
         if process is None:
             E5MessageBox.critical(None,
                 self.trUtf8("Start Debugger"),
-                self.trUtf8("""<p>The debugger backend could not be started.</p>"""))
+                self.trUtf8(
+                    """<p>The debugger backend could not be started.</p>"""))
         return process, self.__isNetworked
 
     def startRemoteForProject(self, port, runInConsole):
@@ -287,11 +295,14 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 # set translation function
                 if project.getDebugProperty("PATHTRANSLATION"):
-                    self.translateRemote = project.getDebugProperty("REMOTEPATH")
-                    self.translateLocal = project.getDebugProperty("LOCALPATH")
+                    self.translateRemote = \
+                        project.getDebugProperty("REMOTEPATH")
+                    self.translateLocal = \
+                        project.getDebugProperty("LOCALPATH")
                     self.translate = self.__remoteTranslation
                 else:
                     self.translate = self.__identityTranslation
@@ -330,7 +341,8 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 return process, self.__isNetworked
         
         process = self.__startProcess(interpreter,
@@ -339,7 +351,8 @@
         if process is None:
             E5MessageBox.critical(None,
                 self.trUtf8("Start Debugger"),
-                self.trUtf8("""<p>The debugger backend could not be started.</p>"""))
+                self.trUtf8(
+                    """<p>The debugger backend could not be started.</p>"""))
         return process, self.__isNetworked
 
     def getClientCapabilities(self):
@@ -419,7 +432,8 @@
         
         @param env environment settings (dictionary)
         """
-        self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestEnv, str(env)))
+        self.__sendCommand('{0}{1}\n'.format(
+            DebugProtocol.RequestEnv, str(env)))
         
     def remoteLoad(self, fn, argv, wd, traceInterpreter=False, autoContinue=True,
                    autoFork=False, forkChild=False):
@@ -429,12 +443,13 @@
         @param fn the filename to debug (string)
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
-        @keyparam traceInterpreter flag indicating if the interpreter library should be
-            traced as well (boolean)
-        @keyparam autoContinue flag indicating, that the debugger should not stop
-            at the first executable line (boolean)
+        @keyparam traceInterpreter flag indicating if the interpreter library
+            should be traced as well (boolean)
+        @keyparam autoContinue flag indicating, that the debugger should not
+            stop at the first executable line (boolean)
         @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking (boolean)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
         """
         self.__autoContinue = autoContinue
         self.__scriptName = os.path.abspath(fn)
@@ -444,8 +459,9 @@
         self.__sendCommand('{0}{1}\n'.format(
             DebugProtocol.RequestForkMode, repr((autoFork, forkChild))))
         self.__sendCommand('{0}{1}|{2}|{3}|{4:d}\n'.format(
-            DebugProtocol.RequestLoad, wd, fn, str(Utilities.parseOptionString(argv)),
-             traceInterpreter))
+            DebugProtocol.RequestLoad, wd, fn,
+            str(Utilities.parseOptionString(argv)),
+            traceInterpreter))
         
     def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
         """
@@ -455,7 +471,8 @@
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
         @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking (boolean)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
         """
         self.__scriptName = os.path.abspath(fn)
         
@@ -464,7 +481,8 @@
         self.__sendCommand('{0}{1}\n'.format(
             DebugProtocol.RequestForkMode, repr((autoFork, forkChild))))
         self.__sendCommand('{0}{1}|{2}|{3}\n'.format(
-            DebugProtocol.RequestRun, wd, fn, str(Utilities.parseOptionString(argv))))
+            DebugProtocol.RequestRun, wd, fn,
+            str(Utilities.parseOptionString(argv))))
         
     def remoteCoverage(self, fn, argv, wd, erase=False):
         """
@@ -481,8 +499,8 @@
         wd = self.translate(wd, False)
         fn = self.translate(os.path.abspath(fn), False)
         self.__sendCommand('{0}{1}@@{2}@@{3}@@{4:d}\n'.format(
-            DebugProtocol.RequestCoverage, wd, fn, str(Utilities.parseOptionString(argv)),
-             erase))
+            DebugProtocol.RequestCoverage, wd, fn,
+            str(Utilities.parseOptionString(argv)), erase))
 
     def remoteProfile(self, fn, argv, wd, erase=False):
         """
@@ -491,7 +509,8 @@
         @param fn the filename to run (string)
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
-        @keyparam erase flag indicating that timing info should be cleared first (boolean)
+        @keyparam erase flag indicating that timing info should be cleared
+            first (boolean)
         """
         self.__scriptName = os.path.abspath(fn)
         
@@ -541,7 +560,8 @@
         
         @param special flag indicating a special continue operation (boolean)
         """
-        self.__sendCommand('{0}{1:d}\n'.format(DebugProtocol.RequestContinue, special))
+        self.__sendCommand('{0}{1:d}\n'.format(
+            DebugProtocol.RequestContinue, special))
 
     def remoteBreakpoint(self, fn, line, set, cond=None, temp=False):
         """
@@ -555,7 +575,8 @@
         """
         fn = self.translate(fn, False)
         self.__sendCommand('{0}{1}@@{2:d}@@{3:d}@@{4:d}@@{5}\n'.format(
-                           DebugProtocol.RequestBreak, fn, line, temp, set, cond))
+                           DebugProtocol.RequestBreak, fn, line, temp, set,
+                           cond))
         
     def remoteBreakpointEnable(self, fn, line, enable):
         """
@@ -563,7 +584,8 @@
         
         @param fn filename the breakpoint belongs to (string)
         @param line linenumber of the breakpoint (int)
-        @param enable flag indicating enabling or disabling a breakpoint (boolean)
+        @param enable flag indicating enabling or disabling a breakpoint
+            (boolean)
         """
         fn = self.translate(fn, False)
         self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
@@ -586,7 +608,8 @@
         Public method to set or clear a watch expression.
         
         @param cond expression of the watch expression (string)
-        @param set flag indicating setting or resetting a watch expression (boolean)
+        @param set flag indicating setting or resetting a watch expression
+            (boolean)
         @param temp flag indicating a temporary watch expression (boolean)
         """
         # cond is combination of cond and special (s. watch expression viewer)
@@ -598,7 +621,8 @@
         Public method to enable or disable a watch expression.
         
         @param cond expression of the watch expression (string)
-        @param enable flag indicating enabling or disabling a watch expression (boolean)
+        @param enable flag indicating enabling or disabling a watch expression
+            (boolean)
         """
         # cond is combination of cond and special (s. watch expression viewer)
         self.__sendCommand('{0}{1},{2:d}\n'.format(
@@ -606,7 +630,8 @@
     
     def remoteWatchpointIgnore(self, cond, count):
         """
-        Public method to ignore a watch expression the next couple of occurrences.
+        Public method to ignore a watch expression the next couple of
+        occurrences.
         
         @param cond expression of the watch expression (string)
         @param count number of occurrences to ignore (int)
@@ -635,7 +660,8 @@
         
         @param tid id of the thread (integer)
         """
-        self.__sendCommand('{0}{1:d}\n'.format(DebugProtocol.RequestThreadSet, tid))
+        self.__sendCommand('{0}{1:d}\n'.format(
+            DebugProtocol.RequestThreadSet, tid))
         
     def remoteClientVariables(self, scope, filter, framenr=0):
         """
@@ -658,7 +684,8 @@
         @param framenr framenumber of the variables to retrieve (int)
         """
         self.__sendCommand('{0}{1}, {2:d}, {3:d}, {4}\n'.format(
-            DebugProtocol.RequestVariable, str(var), framenr, scope, str(filter)))
+            DebugProtocol.RequestVariable, str(var), framenr, scope,
+            str(filter)))
         
     def remoteClientSetFilter(self, scope, filter):
         """
@@ -680,11 +707,13 @@
             cmd = "on"
         else:
             cmd = "off"
-        self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestCallTrace, cmd))
+        self.__sendCommand('{0}{1}\n'.format(
+            DebugProtocol.RequestCallTrace, cmd))
     
     def remoteEval(self, arg):
         """
-        Public method to evaluate arg in the current context of the debugged program.
+        Public method to evaluate arg in the current context of the debugged
+        program.
         
         @param arg the arguments to evaluate (string)
         """
@@ -692,7 +721,8 @@
         
     def remoteExec(self, stmt):
         """
-        Public method to execute stmt in the current context of the debugged program.
+        Public method to execute stmt in the current context of the debugged
+        program.
         
         @param stmt statement to execute (string)
         """
@@ -717,7 +747,8 @@
         
         @param text the text to be completed (string)
         """
-        self.__sendCommand("{0}{1}\n".format(DebugProtocol.RequestCompletion, text))
+        self.__sendCommand("{0}{1}\n".format(
+            DebugProtocol.RequestCompletion, text))
         
     def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
         """
@@ -727,11 +758,13 @@
         @param tn the testname to load (string)
         @param tfn the test function name to load tests from (string)
         @param failed list of failed test, if only failed test should be run
-                (list of strings)
-        @param cov flag indicating collection of coverage data is requested (boolean)
+            (list of strings)
+        @param cov flag indicating collection of coverage data is requested
+            (boolean)
         @param covname filename to be used to assemble the coverage caches
-                filename (string)
-        @param coverase flag indicating erasure of coverage data is requested (boolean)
+            filename (string)
+        @param coverase flag indicating erasure of coverage data is requested
+            (boolean)
         """
         self.__scriptName = os.path.abspath(fn)
         
@@ -756,7 +789,8 @@
         """
         Private method to ask the user which branch of a fork to follow.
         """
-        selections = [self.trUtf8("Parent Process"), self.trUtf8("Child process")]
+        selections = [self.trUtf8("Parent Process"),
+                      self.trUtf8("Child process")]
         res, ok = QInputDialog.getItem(
             None,
             self.trUtf8("Client forking"),
@@ -812,8 +846,9 @@
                         self.__autoContinue = False
                         QTimer.singleShot(0, self.remoteContinue)
                     else:
-                        self.debugServer.signalClientLine(cf[0], int(cf[1]),
-                                                    resp == DebugProtocol.ResponseStack)
+                        self.debugServer.signalClientLine(
+                            cf[0], int(cf[1]),
+                            resp == DebugProtocol.ResponseStack)
                         self.debugServer.signalClientStack(stack)
                     continue
                 
@@ -829,7 +864,8 @@
                 
                 if resp == DebugProtocol.ResponseThreadList:
                     currentId, threadList = eval(evalArg)
-                    self.debugServer.signalClientThreadList(currentId, threadList)
+                    self.debugServer.signalClientThreadList(
+                        currentId, threadList)
                     continue
                 
                 if resp == DebugProtocol.ResponseThreadSet:
@@ -881,7 +917,8 @@
                         exctype = None
                         excmessage = ''
                         stack = []
-                    self.debugServer.signalClientException(exctype, excmessage, stack)
+                    self.debugServer.signalClientException(
+                        exctype, excmessage, stack)
                     continue
                 
                 if resp == DebugProtocol.ResponseSyntax:
@@ -897,7 +934,8 @@
                         cn = 0
                     if cn is None:
                         cn = 0
-                    self.debugServer.signalClientSyntaxError(message, fn, ln, cn)
+                    self.debugServer.signalClientSyntaxError(
+                        message, fn, ln, cn)
                     continue
                 
                 if resp == DebugProtocol.ResponseExit:
@@ -916,7 +954,8 @@
                     fn, lineno = evalArg.split(',')
                     lineno = int(lineno)
                     fn = self.translate(fn, True)
-                    self.debugServer.signalClientBreakConditionError(fn, lineno)
+                    self.debugServer.signalClientBreakConditionError(
+                        fn, lineno)
                     continue
                 
                 if resp == DebugProtocol.ResponseClearWatch:
@@ -934,7 +973,8 @@
                 
                 if resp == DebugProtocol.ResponseBanner:
                     version, platform, dbgclient = eval(evalArg)
-                    self.debugServer.signalClientBanner(version, platform, dbgclient)
+                    self.debugServer.signalClientBanner(
+                        version, platform, dbgclient)
                     continue
                 
                 if resp == DebugProtocol.ResponseCapabilities:
@@ -972,12 +1012,14 @@
                 
                 if resp == DebugProtocol.ResponseUTTestFailed:
                     testname, traceback, id = eval(evalArg)
-                    self.debugServer.clientUtTestFailed(testname, traceback, id)
+                    self.debugServer.clientUtTestFailed(
+                        testname, traceback, id)
                     continue
                 
                 if resp == DebugProtocol.ResponseUTTestErrored:
                     testname, traceback, id = eval(evalArg)
-                    self.debugServer.clientUtTestErrored(testname, traceback, id)
+                    self.debugServer.clientUtTestErrored(
+                        testname, traceback, id)
                     continue
                 
                 if resp == DebugProtocol.ResponseUTTestSkipped:
@@ -987,12 +1029,14 @@
                 
                 if resp == DebugProtocol.ResponseUTTestFailedExpected:
                     testname, traceback, id = eval(line[eoc:-1])
-                    self.debugServer.clientUtTestFailedExpected(testname, traceback, id)
+                    self.debugServer.clientUtTestFailedExpected(
+                        testname, traceback, id)
                     continue
                 
                 if resp == DebugProtocol.ResponseUTTestSucceededUnexpected:
                     testname, id = eval(line[eoc:-1])
-                    self.debugServer.clientUtTestSucceededUnexpected(testname, id)
+                    self.debugServer.clientUtTestSucceededUnexpected(
+                        testname, id)
                     continue
                 
                 if resp == DebugProtocol.ResponseUTFinished:
--- a/Debugger/DebuggerInterfacePython3.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/DebuggerInterfacePython3.py	Sun Oct 06 19:00:04 2013 +0200
@@ -73,7 +73,8 @@
         # set default values for capabilities of clients
         self.clientCapabilities = ClientDefaultCapabilities
         
-        self.codec = QTextCodec.codecForName(str(Preferences.getSystem("StringEncoding")))
+        self.codec = QTextCodec.codecForName(
+            str(Preferences.getSystem("StringEncoding")))
         
         if passive:
             # set translation function
@@ -120,7 +121,8 @@
         
         @param program name of the executable to start (string)
         @param arguments arguments to be passed to the program (list of string)
-        @param environment dictionary of environment settings to pass (dict of string)
+        @param environment dictionary of environment settings to pass
+            (dict of string)
         @return the process object (QProcess) or None
         """
         proc = QProcess()
@@ -158,19 +160,22 @@
         debugClientType = Preferences.getDebugger("DebugClientType3")
         if debugClientType == "standard":
             debugClient = os.path.join(getConfig('ericDir'),
-                                       "DebugClients", "Python3", "DebugClient.py")
+                                       "DebugClients", "Python3",
+                                       "DebugClient.py")
         elif debugClientType == "threaded":
             debugClient = os.path.join(getConfig('ericDir'),
-                                       "DebugClients", "Python3", "DebugClientThreads.py")
+                                       "DebugClients", "Python3",
+                                       "DebugClientThreads.py")
         else:
             debugClient = Preferences.getDebugger("DebugClient3")
             if debugClient == "":
                 debugClient = os.path.join(sys.path[0],
-                                           "DebugClients", "Python3", "DebugClient.py")
+                                           "DebugClients", "Python3",
+                                           "DebugClient.py")
         
         redirect = str(Preferences.getDebugger("Python3Redirect"))
-        noencoding = \
-            Preferences.getDebugger("Python3NoEncoding") and '--no-encoding' or ''
+        noencoding = Preferences.getDebugger("Python3NoEncoding") and \
+            '--no-encoding' or ''
         
         if Preferences.getDebugger("RemoteDbgEnabled"):
             ipaddr = self.debugServer.getHostAddress(False)
@@ -188,7 +193,8 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 
                 # set translation function
                 if Preferences.getDebugger("PathTranslation"):
@@ -233,7 +239,8 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 return process, self.__isNetworked
         
         process = self.__startProcess(interpreter,
@@ -242,7 +249,8 @@
         if process is None:
             E5MessageBox.critical(None,
                 self.trUtf8("Start Debugger"),
-                self.trUtf8("""<p>The debugger backend could not be started.</p>"""))
+                self.trUtf8(
+                    """<p>The debugger backend could not be started.</p>"""))
         return process, self.__isNetworked
 
     def startRemoteForProject(self, port, runInConsole):
@@ -283,11 +291,14 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 # set translation function
                 if project.getDebugProperty("PATHTRANSLATION"):
-                    self.translateRemote = project.getDebugProperty("REMOTEPATH")
-                    self.translateLocal = project.getDebugProperty("LOCALPATH")
+                    self.translateRemote = \
+                        project.getDebugProperty("REMOTEPATH")
+                    self.translateLocal = \
+                        project.getDebugProperty("LOCALPATH")
                     self.translate = self.__remoteTranslation
                 else:
                     self.translate = self.__identityTranslation
@@ -326,7 +337,8 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 return process, self.__isNetworked
         
         process = self.__startProcess(interpreter,
@@ -335,7 +347,8 @@
         if process is None:
             E5MessageBox.critical(None,
                 self.trUtf8("Start Debugger"),
-                self.trUtf8("""<p>The debugger backend could not be started.</p>"""))
+                self.trUtf8(
+                    """<p>The debugger backend could not be started.</p>"""))
         return process, self.__isNetworked
 
     def getClientCapabilities(self):
@@ -415,22 +428,24 @@
         
         @param env environment settings (dictionary)
         """
-        self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestEnv, str(env)))
+        self.__sendCommand('{0}{1}\n'.format(
+            DebugProtocol.RequestEnv, str(env)))
     
-    def remoteLoad(self, fn, argv, wd, traceInterpreter=False, autoContinue=True,
-                   autoFork=False, forkChild=False):
+    def remoteLoad(self, fn, argv, wd, traceInterpreter=False,
+                   autoContinue=True, autoFork=False, forkChild=False):
         """
         Public method to load a new program to debug.
         
         @param fn the filename to debug (string)
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
-        @keyparam traceInterpreter flag indicating if the interpreter library should be
-            traced as well (boolean)
-        @keyparam autoContinue flag indicating, that the debugger should not stop
-            at the first executable line (boolean)
+        @keyparam traceInterpreter flag indicating if the interpreter library
+            should be traced as well (boolean)
+        @keyparam autoContinue flag indicating, that the debugger should not
+            stop at the first executable line (boolean)
         @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking (boolean)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
         """
         self.__autoContinue = autoContinue
         self.__scriptName = os.path.abspath(fn)
@@ -440,8 +455,9 @@
         self.__sendCommand('{0}{1}\n'.format(
             DebugProtocol.RequestForkMode, repr((autoFork, forkChild))))
         self.__sendCommand('{0}{1}|{2}|{3}|{4:d}\n'.format(
-            DebugProtocol.RequestLoad, wd, fn, str(Utilities.parseOptionString(argv)),
-             traceInterpreter))
+            DebugProtocol.RequestLoad, wd, fn,
+            str(Utilities.parseOptionString(argv)),
+            traceInterpreter))
     
     def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
         """
@@ -451,7 +467,8 @@
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
         @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking (boolean)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
         """
         self.__scriptName = os.path.abspath(fn)
         
@@ -460,7 +477,8 @@
         self.__sendCommand('{0}{1}\n'.format(
             DebugProtocol.RequestForkMode, repr((autoFork, forkChild))))
         self.__sendCommand('{0}{1}|{2}|{3}\n'.format(
-            DebugProtocol.RequestRun, wd, fn, str(Utilities.parseOptionString(argv))))
+            DebugProtocol.RequestRun, wd, fn,
+            str(Utilities.parseOptionString(argv))))
     
     def remoteCoverage(self, fn, argv, wd, erase=False):
         """
@@ -477,8 +495,9 @@
         wd = self.translate(wd, False)
         fn = self.translate(os.path.abspath(fn), False)
         self.__sendCommand('{0}{1}@@{2}@@{3}@@{4:d}\n'.format(
-            DebugProtocol.RequestCoverage, wd, fn, str(Utilities.parseOptionString(argv)),
-             erase))
+            DebugProtocol.RequestCoverage, wd, fn,
+            str(Utilities.parseOptionString(argv)),
+            erase))
 
     def remoteProfile(self, fn, argv, wd, erase=False):
         """
@@ -487,7 +506,8 @@
         @param fn the filename to run (string)
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
-        @keyparam erase flag indicating that timing info should be cleared first (boolean)
+        @keyparam erase flag indicating that timing info should be cleared
+            first (boolean)
         """
         self.__scriptName = os.path.abspath(fn)
         
@@ -537,7 +557,8 @@
         
         @param special flag indicating a special continue operation
         """
-        self.__sendCommand('{0}{1:d}\n'.format(DebugProtocol.RequestContinue, special))
+        self.__sendCommand('{0}{1:d}\n'.format(
+            DebugProtocol.RequestContinue, special))
 
     def remoteBreakpoint(self, fn, line, set, cond=None, temp=False):
         """
@@ -551,7 +572,7 @@
         """
         fn = self.translate(fn, False)
         self.__sendCommand('{0}{1}@@{2:d}@@{3:d}@@{4:d}@@{5}\n'.format(
-                           DebugProtocol.RequestBreak, fn, line, temp, set, cond))
+            DebugProtocol.RequestBreak, fn, line, temp, set, cond))
     
     def remoteBreakpointEnable(self, fn, line, enable):
         """
@@ -559,7 +580,8 @@
         
         @param fn filename the breakpoint belongs to (string)
         @param line linenumber of the breakpoint (int)
-        @param enable flag indicating enabling or disabling a breakpoint (boolean)
+        @param enable flag indicating enabling or disabling a breakpoint
+            (boolean)
         """
         fn = self.translate(fn, False)
         self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
@@ -582,7 +604,8 @@
         Public method to set or clear a watch expression.
         
         @param cond expression of the watch expression (string)
-        @param set flag indicating setting or resetting a watch expression (boolean)
+        @param set flag indicating setting or resetting a watch expression
+            (boolean)
         @param temp flag indicating a temporary watch expression (boolean)
         """
         # cond is combination of cond and special (s. watch expression viewer)
@@ -594,7 +617,8 @@
         Public method to enable or disable a watch expression.
         
         @param cond expression of the watch expression (string)
-        @param enable flag indicating enabling or disabling a watch expression (boolean)
+        @param enable flag indicating enabling or disabling a watch expression
+            (boolean)
         """
         # cond is combination of cond and special (s. watch expression viewer)
         self.__sendCommand('{0}{1},{2:d}\n'.format(
@@ -602,7 +626,8 @@
     
     def remoteWatchpointIgnore(self, cond, count):
         """
-        Public method to ignore a watch expression the next couple of occurrences.
+        Public method to ignore a watch expression the next couple of
+        occurrences.
         
         @param cond expression of the watch expression (string)
         @param count number of occurrences to ignore (int)
@@ -631,7 +656,8 @@
         
         @param tid id of the thread (integer)
         """
-        self.__sendCommand('{0}{1:d}\n'.format(DebugProtocol.RequestThreadSet, tid))
+        self.__sendCommand('{0}{1:d}\n'.format(
+            DebugProtocol.RequestThreadSet, tid))
         
     def remoteClientVariables(self, scope, filter, framenr=0):
         """
@@ -654,7 +680,8 @@
         @param framenr framenumber of the variables to retrieve (int)
         """
         self.__sendCommand('{0}{1}, {2:d}, {3:d}, {4}\n'.format(
-            DebugProtocol.RequestVariable, str(var), framenr, scope, str(filter)))
+            DebugProtocol.RequestVariable, str(var), framenr, scope,
+            str(filter)))
     
     def remoteClientSetFilter(self, scope, filter):
         """
@@ -676,11 +703,13 @@
             cmd = "on"
         else:
             cmd = "off"
-        self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestCallTrace, cmd))
+        self.__sendCommand('{0}{1}\n'.format(
+            DebugProtocol.RequestCallTrace, cmd))
     
     def remoteEval(self, arg):
         """
-        Public method to evaluate arg in the current context of the debugged program.
+        Public method to evaluate arg in the current context of the debugged
+        program.
         
         @param arg the arguments to evaluate (string)
         """
@@ -688,7 +717,8 @@
     
     def remoteExec(self, stmt):
         """
-        Public method to execute stmt in the current context of the debugged program.
+        Public method to execute stmt in the current context of the debugged
+        program.
         
         @param stmt statement to execute (string)
         """
@@ -713,7 +743,8 @@
         
         @param text the text to be completed (string)
         """
-        self.__sendCommand("{0}{1}\n".format(DebugProtocol.RequestCompletion, text))
+        self.__sendCommand("{0}{1}\n".format(
+            DebugProtocol.RequestCompletion, text))
     
     def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
         """
@@ -723,11 +754,13 @@
         @param tn the testname to load (string)
         @param tfn the test function name to load tests from (string)
         @param failed list of failed test, if only failed test should be run
-                (list of strings)
-        @param cov flag indicating collection of coverage data is requested (boolean)
+            (list of strings)
+        @param cov flag indicating collection of coverage data is requested
+            (boolean)
         @param covname filename to be used to assemble the coverage caches
-                filename (string)
-        @param coverase flag indicating erasure of coverage data is requested (boolean)
+            filename (string)
+        @param coverase flag indicating erasure of coverage data is requested
+            (boolean)
         """
         self.__scriptName = os.path.abspath(fn)
         
@@ -752,7 +785,8 @@
         """
         Private method to ask the user which branch of a fork to follow.
         """
-        selections = [self.trUtf8("Parent Process"), self.trUtf8("Child process")]
+        selections = [self.trUtf8("Parent Process"),
+                      self.trUtf8("Child process")]
         res, ok = QInputDialog.getItem(
             None,
             self.trUtf8("Client forking"),
@@ -807,8 +841,9 @@
                         self.__autoContinue = False
                         QTimer.singleShot(0, self.remoteContinue)
                     else:
-                        self.debugServer.signalClientLine(cf[0], int(cf[1]),
-                                                    resp == DebugProtocol.ResponseStack)
+                        self.debugServer.signalClientLine(
+                            cf[0], int(cf[1]),
+                            resp == DebugProtocol.ResponseStack)
                         self.debugServer.signalClientStack(stack)
                     continue
                 
@@ -824,7 +859,8 @@
                 
                 if resp == DebugProtocol.ResponseThreadList:
                     currentId, threadList = eval(line[eoc:-1])
-                    self.debugServer.signalClientThreadList(currentId, threadList)
+                    self.debugServer.signalClientThreadList(
+                        currentId, threadList)
                     continue
                 
                 if resp == DebugProtocol.ResponseThreadSet:
@@ -877,7 +913,8 @@
                         exctype = None
                         excmessage = ''
                         stack = []
-                    self.debugServer.signalClientException(exctype, excmessage, stack)
+                    self.debugServer.signalClientException(
+                        exctype, excmessage, stack)
                     continue
                 
                 if resp == DebugProtocol.ResponseSyntax:
@@ -894,7 +931,8 @@
                         cn = 0
                     if cn is None:
                         cn = 0
-                    self.debugServer.signalClientSyntaxError(message, fn, ln, cn)
+                    self.debugServer.signalClientSyntaxError(
+                        message, fn, ln, cn)
                     continue
                 
                 if resp == DebugProtocol.ResponseExit:
@@ -913,7 +951,8 @@
                     fn, lineno = line[eoc:-1].split(',')
                     lineno = int(lineno)
                     fn = self.translate(fn, True)
-                    self.debugServer.signalClientBreakConditionError(fn, lineno)
+                    self.debugServer.signalClientBreakConditionError(
+                        fn, lineno)
                     continue
                 
                 if resp == DebugProtocol.ResponseClearWatch:
@@ -933,7 +972,8 @@
                 
                 if resp == DebugProtocol.ResponseBanner:
                     version, platform, dbgclient = eval(line[eoc:-1])
-                    self.debugServer.signalClientBanner(version, platform, dbgclient)
+                    self.debugServer.signalClientBanner(
+                        version, platform, dbgclient)
                     continue
                 
                 if resp == DebugProtocol.ResponseCapabilities:
@@ -971,12 +1011,14 @@
                 
                 if resp == DebugProtocol.ResponseUTTestFailed:
                     testname, traceback, id = eval(line[eoc:-1])
-                    self.debugServer.clientUtTestFailed(testname, traceback, id)
+                    self.debugServer.clientUtTestFailed(
+                        testname, traceback, id)
                     continue
                 
                 if resp == DebugProtocol.ResponseUTTestErrored:
                     testname, traceback, id = eval(line[eoc:-1])
-                    self.debugServer.clientUtTestErrored(testname, traceback, id)
+                    self.debugServer.clientUtTestErrored(
+                        testname, traceback, id)
                     continue
                 
                 if resp == DebugProtocol.ResponseUTTestSkipped:
@@ -986,12 +1028,14 @@
                 
                 if resp == DebugProtocol.ResponseUTTestFailedExpected:
                     testname, traceback, id = eval(line[eoc:-1])
-                    self.debugServer.clientUtTestFailedExpected(testname, traceback, id)
+                    self.debugServer.clientUtTestFailedExpected(
+                        testname, traceback, id)
                     continue
                 
                 if resp == DebugProtocol.ResponseUTTestSucceededUnexpected:
                     testname, id = eval(line[eoc:-1])
-                    self.debugServer.clientUtTestSucceededUnexpected(testname, id)
+                    self.debugServer.clientUtTestSucceededUnexpected(
+                        testname, id)
                     continue
                 
                 if resp == DebugProtocol.ResponseUTFinished:
--- a/Debugger/DebuggerInterfaceRuby.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/DebuggerInterfaceRuby.py	Sun Oct 06 19:00:04 2013 +0200
@@ -67,7 +67,8 @@
         # set default values for capabilities of clients
         self.clientCapabilities = ClientDefaultCapabilities
         
-        self.codec = QTextCodec.codecForName(str(Preferences.getSystem("StringEncoding")))
+        self.codec = QTextCodec.codecForName(
+            str(Preferences.getSystem("StringEncoding")))
         
         if passive:
             # set translation function
@@ -111,7 +112,8 @@
         
         @param program name of the executable to start (string)
         @param arguments arguments to be passed to the program (list of string)
-        @param environment dictionary of environment settings to pass (dict of string)
+        @param environment dictionary of environment settings to pass
+            (dict of string)
         @return the process object (QProcess) or None
         """
         proc = QProcess()
@@ -163,7 +165,8 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 
                 # set translation function
                 if Preferences.getDebugger("PathTranslation"):
@@ -208,7 +211,8 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 return process, self.__isNetworked
         
         process = self.__startProcess(interpreter,
@@ -217,7 +221,8 @@
         if process is None:
             E5MessageBox.critical(None,
                 self.trUtf8("Start Debugger"),
-                self.trUtf8("""<p>The debugger backend could not be started.</p>"""))
+                self.trUtf8(
+                    """<p>The debugger backend could not be started.</p>"""))
         return process, self.__isNetworked
 
     def startRemoteForProject(self, port, runInConsole):
@@ -256,11 +261,14 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 # set translation function
                 if project.getDebugProperty("PATHTRANSLATION"):
-                    self.translateRemote = project.getDebugProperty("REMOTEPATH")
-                    self.translateLocal = project.getDebugProperty("LOCALPATH")
+                    self.translateRemote = \
+                        project.getDebugProperty("REMOTEPATH")
+                    self.translateLocal = \
+                        project.getDebugProperty("LOCALPATH")
                     self.translate = self.__remoteTranslation
                 else:
                     self.translate = self.__identityTranslation
@@ -299,7 +307,8 @@
                     E5MessageBox.critical(None,
                         self.trUtf8("Start Debugger"),
                         self.trUtf8(
-                            """<p>The debugger backend could not be started.</p>"""))
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
                 return process, self.__isNetworked
         
         process = self.__startProcess(interpreter,
@@ -308,7 +317,8 @@
         if process is None:
             E5MessageBox.critical(None,
                 self.trUtf8("Start Debugger"),
-                self.trUtf8("""<p>The debugger backend could not be started.</p>"""))
+                self.trUtf8(
+                    """<p>The debugger backend could not be started.</p>"""))
         return process, self.__isNetworked
 
     def getClientCapabilities(self):
@@ -388,21 +398,23 @@
         
         @param env environment settings (dictionary)
         """
-        self.__sendCommand('{0}{1}\n'.format(DebugProtocol.RequestEnv, str(env)))
+        self.__sendCommand('{0}{1}\n'.format(
+            DebugProtocol.RequestEnv, str(env)))
         
-    def remoteLoad(self, fn, argv, wd, traceInterpreter=False, autoContinue=True,
-                   autoFork=False, forkChild=False):
+    def remoteLoad(self, fn, argv, wd, traceInterpreter=False,
+                   autoContinue=True, autoFork=False, forkChild=False):
         """
         Public method to load a new program to debug.
         
         @param fn the filename to debug (string)
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
-        @keyparam traceInterpreter flag indicating if the interpreter library should be
-            traced as well (boolean)
-        @keyparam autoContinue flag indicating, that the debugger should not stop
-            at the first executable line (boolean)
-        @keyparam autoFork flag indicating the automatic fork mode (boolean) (ignored)
+        @keyparam traceInterpreter flag indicating if the interpreter library
+            should be traced as well (boolean)
+        @keyparam autoContinue flag indicating, that the debugger should not
+            stop at the first executable line (boolean)
+        @keyparam autoFork flag indicating the automatic fork mode (boolean)
+            (ignored)
         @keyparam forkChild flag indicating to debug the child after forking
             (boolean) (ignored)
         """
@@ -411,8 +423,9 @@
         wd = self.translate(wd, False)
         fn = self.translate(os.path.abspath(fn), False)
         self.__sendCommand('{0}{1}|{2}|{3}|{4:d}\n'.format(
-            DebugProtocol.RequestLoad, wd, fn, str(Utilities.parseOptionString(argv)),
-             traceInterpreter))
+            DebugProtocol.RequestLoad, wd, fn,
+            str(Utilities.parseOptionString(argv)),
+            traceInterpreter))
         
     def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
         """
@@ -421,14 +434,16 @@
         @param fn the filename to run (string)
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
-        @keyparam autoFork flag indicating the automatic fork mode (boolean) (ignored)
+        @keyparam autoFork flag indicating the automatic fork mode (boolean)
+            (ignored)
         @keyparam forkChild flag indicating to debug the child after forking
             (boolean) (ignored)
         """
         wd = self.translate(wd, False)
         fn = self.translate(os.path.abspath(fn), False)
         self.__sendCommand('{0}{1}|{2}|{3}\n'.format(
-            DebugProtocol.RequestRun, wd, fn, str(Utilities.parseOptionString(argv))))
+            DebugProtocol.RequestRun, wd, fn,
+            str(Utilities.parseOptionString(argv))))
         
     def remoteCoverage(self, fn, argv, wd, erase=False):
         """
@@ -451,7 +466,8 @@
         @param fn the filename to run (string)
         @param argv the commandline arguments to pass to the program (string)
         @param wd the working directory for the program (string)
-        @keyparam erase flag indicating that timing info should be cleared first (boolean)
+        @keyparam erase flag indicating that timing info should be cleared
+            first (boolean)
         @exception NotImplementedError raised to indicate that this interface
             is not supported
         """
@@ -497,7 +513,8 @@
         
         @param special flag indicating a special continue operation (boolean)
         """
-        self.__sendCommand('{0}{1:d}\n'.format(DebugProtocol.RequestContinue, special))
+        self.__sendCommand('{0}{1:d}\n'.format(
+            DebugProtocol.RequestContinue, special))
 
     def remoteBreakpoint(self, fn, line, set, cond=None, temp=False):
         """
@@ -511,7 +528,7 @@
         """
         fn = self.translate(fn, False)
         self.__sendCommand('{0}{1}@@{2:d}@@{3:d}@@{4:d}@@{5}\n'.format(
-                           DebugProtocol.RequestBreak, fn, line, temp, set, cond))
+            DebugProtocol.RequestBreak, fn, line, temp, set, cond))
         
     def remoteBreakpointEnable(self, fn, line, enable):
         """
@@ -519,7 +536,8 @@
         
         @param fn filename the breakpoint belongs to (string)
         @param line linenumber of the breakpoint (int)
-        @param enable flag indicating enabling or disabling a breakpoint (boolean)
+        @param enable flag indicating enabling or disabling a breakpoint
+            (boolean)
         """
         fn = self.translate(fn, False)
         self.__sendCommand('{0}{1},{2:d},{3:d}\n'.format(
@@ -542,7 +560,8 @@
         Public method to set or clear a watch expression.
         
         @param cond expression of the watch expression (string)
-        @param set flag indicating setting or resetting a watch expression (boolean)
+        @param set flag indicating setting or resetting a watch expression
+            (boolean)
         @param temp flag indicating a temporary watch expression (boolean)
         """
         # cond is combination of cond and special (s. watch expression viewer)
@@ -554,7 +573,8 @@
         Public method to enable or disable a watch expression.
         
         @param cond expression of the watch expression (string)
-        @param enable flag indicating enabling or disabling a watch expression (boolean)
+        @param enable flag indicating enabling or disabling a watch expression
+            (boolean)
         """
         # cond is combination of cond and special (s. watch expression viewer)
         self.__sendCommand('{0}{1},{2:d}\n'.format(
@@ -562,7 +582,8 @@
     
     def remoteWatchpointIgnore(self, cond, count):
         """
-        Public method to ignore a watch expression the next couple of occurrences.
+        Public method to ignore a watch expression the next couple of
+        occurrences.
         
         @param cond expression of the watch expression (string)
         @param count number of occurrences to ignore (int)
@@ -614,7 +635,8 @@
         @param framenr framenumber of the variables to retrieve (int)
         """
         self.__sendCommand('{0}{1}, {2:d}, {3:d}, {4}\n'.format(
-            DebugProtocol.RequestVariable, str(var), framenr, scope, str(filter)))
+            DebugProtocol.RequestVariable, str(var), framenr, scope,
+            str(filter)))
         
     def remoteClientSetFilter(self, scope, filter):
         """
@@ -636,7 +658,8 @@
         
     def remoteEval(self, arg):
         """
-        Public method to evaluate arg in the current context of the debugged program.
+        Public method to evaluate arg in the current context of the debugged
+        program.
         
         @param arg the arguments to evaluate (string)
         """
@@ -644,7 +667,8 @@
         
     def remoteExec(self, stmt):
         """
-        Public method to execute stmt in the current context of the debugged program.
+        Public method to execute stmt in the current context of the debugged
+        program.
         
         @param stmt statement to execute (string)
         """
@@ -669,7 +693,8 @@
         
         @param text the text to be completed (string)
         """
-        self.__sendCommand("{0}{1}\n".format(DebugProtocol.RequestCompletion, text))
+        self.__sendCommand("{0}{1}\n".format(
+            DebugProtocol.RequestCompletion, text))
         
     def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
         """
@@ -679,11 +704,13 @@
         @param tn the testname to load (string)
         @param tfn the test function name to load tests from (string)
         @param failed list of failed test, if only failed test should be run
-                (list of strings)
-        @param cov flag indicating collection of coverage data is requested (boolean)
+            (list of strings)
+        @param cov flag indicating collection of coverage data is requested
+            (boolean)
         @param covname filename to be used to assemble the coverage caches
-                filename (string)
-        @param coverase flag indicating erasure of coverage data is requested (boolean)
+            filename (string)
+        @param coverase flag indicating erasure of coverage data is requested
+            (boolean)
         @exception NotImplementedError raised to indicate that this interface
             is not supported
         """
@@ -793,7 +820,8 @@
                         exctype = None
                         excmessage = ''
                         stack = []
-                    self.debugServer.signalClientException(exctype, excmessage, stack)
+                    self.debugServer.signalClientException(
+                        exctype, excmessage, stack)
                     continue
                 
                 if resp == DebugProtocol.ResponseSyntax:
@@ -808,7 +836,8 @@
                         fn = ''
                         ln = 0
                         cn = 0
-                    self.debugServer.signalClientSyntaxError(message, fn, ln, cn)
+                    self.debugServer.signalClientSyntaxError(
+                        message, fn, ln, cn)
                     continue
                 
                 if resp == DebugProtocol.ResponseExit:
@@ -829,7 +858,8 @@
                 
                 if resp == DebugProtocol.ResponseBanner:
                     version, platform, dbgclient = eval(line[eoc:-1])
-                    self.debugServer.signalClientBanner(version, platform, dbgclient)
+                    self.debugServer.signalClientBanner(
+                        version, platform, dbgclient)
                     continue
                 
                 if resp == DebugProtocol.ResponseCapabilities:
--- a/Debugger/EditBreakpointDialog.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/EditBreakpointDialog.py	Sun Oct 06 19:00:04 2013 +0200
@@ -151,7 +151,8 @@
         Public method to retrieve the entered data for an add.
         
         @return a tuple containing the new breakpoints properties
-            (filename, lineno, condition, temporary flag, enabled flag, ignore count)
+            (filename, lineno, condition, temporary flag, enabled flag,
+            ignore count)
         """
         fn = self.filenameCombo.currentText()
         if not fn:
@@ -161,5 +162,6 @@
         
         return (fn, self.linenoSpinBox.value(),
                 self.conditionCombo.currentText(),
-                self.temporaryCheckBox.isChecked(), self.enabledCheckBox.isChecked(),
+                self.temporaryCheckBox.isChecked(),
+                self.enabledCheckBox.isChecked(),
                 self.ignoreSpinBox.value())
--- a/Debugger/EditWatchpointDialog.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/EditWatchpointDialog.py	Sun Oct 06 19:00:04 2013 +0200
@@ -21,7 +21,8 @@
         Constructor
         
         @param properties properties for the watch expression (tuple)
-            (expression, temporary flag, enabled flag, ignore count, special condition)
+            (expression, temporary flag, enabled flag, ignore count,
+            special condition)
         @param parent the parent of this dialog
         @param name the widget name of this dialog
         @param modal flag indicating a modal dialog
@@ -66,7 +67,8 @@
         
     def __textChanged(self, txt):
         """
-        Private slot to handle the text changed signal of the condition line edit.
+        Private slot to handle the text changed signal of the condition line
+        edit.
         
         @param txt text of the line edit (string)
         """
@@ -85,7 +87,8 @@
         Public method to retrieve the entered data.
         
         @return a tuple containing the watch expressions new properties
-            (expression, temporary flag, enabled flag, ignore count, special condition)
+            (expression, temporary flag, enabled flag, ignore count,
+            special condition)
         """
         if self.conditionButton.isChecked():
             return (self.conditionEdit.text(),
--- a/Debugger/ExceptionLogger.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/ExceptionLogger.py	Sun Oct 06 19:00:04 2013 +0200
@@ -47,10 +47,11 @@
         self.setWhatsThis(self.trUtf8(
             """<b>Exceptions Logger</b>"""
             """<p>This windows shows a trace of all exceptions, that have"""
-            """ occured during the last debugging session. Initially only the"""
-            """ exception type and exception message are shown. After"""
-            """ the expansion of this entry, the complete call stack as reported"""
-            """ by the client is show with the most recent call first.</p>"""
+            """ occured during the last debugging session. Initially only"""
+            """ the exception type and exception message are shown. After"""
+            """ the expansion of this entry, the complete call stack as"""
+            """ reported by the client is show with the most recent call"""
+            """ first.</p>"""
         ))
         
         self.menu = QMenu(self)
@@ -112,7 +113,8 @@
             
     def debuggingStarted(self):
         """
-        Public slot to clear the listview upon starting a new debugging session.
+        Public slot to clear the listview upon starting a new debugging
+        session.
         """
         self.clear()
         
@@ -136,4 +138,5 @@
         """
         Private method to open the configuration dialog.
         """
-        e5App().getObject("UserInterface").showPreferences("debuggerGeneralPage")
+        e5App().getObject("UserInterface")\
+            .showPreferences("debuggerGeneralPage")
--- a/Debugger/ExceptionsFilterDialog.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/ExceptionsFilterDialog.py	Sun Oct 06 19:00:04 2013 +0200
@@ -33,7 +33,8 @@
         
         if ignore:
             self.setWindowTitle(self.trUtf8("Ignored Exceptions"))
-            self.exceptionList.setToolTip(self.trUtf8("List of ignored exceptions"))
+            self.exceptionList.setToolTip(
+                self.trUtf8("List of ignored exceptions"))
         
         self.okButton = self.buttonBox.button(QDialogButtonBox.Ok)
     
@@ -42,7 +43,8 @@
         """
         Private slot to handle the change of the selection.
         """
-        self.deleteButton.setEnabled(len(self.exceptionList.selectedItems()) > 0)
+        self.deleteButton.setEnabled(
+            len(self.exceptionList.selectedItems()) > 0)
     
     @pyqtSlot()
     def on_deleteButton_clicked(self):
--- a/Debugger/StartDialog.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/StartDialog.py	Sun Oct 06 19:00:04 2013 +0200
@@ -26,9 +26,10 @@
     the commandline parameters, the working directory and
     whether exception reporting should be disabled.
     """
-    def __init__(self, caption, argvList, wdList, envList, exceptions, parent=None,
-        type=0, modfuncList=None, tracePython=False, autoClearShell=True,
-        autoContinue=True, autoFork=False, forkChild=False):
+    def __init__(self, caption, argvList, wdList, envList, exceptions,
+        parent=None, type=0, modfuncList=None, tracePython=False,
+        autoClearShell=True, autoContinue=True, autoFork=False,
+        forkChild=False):
         """
         Constructor
         
@@ -45,15 +46,17 @@
                 <li>2 = start coverage dialog</li>
                 <li>3 = start profile dialog</li>
                 </ul>
-        @keyparam modfuncList history list of module functions (list of strings)
+        @keyparam modfuncList history list of module functions
+            (list of strings)
         @keyparam tracePython flag indicating if the Python library should
             be traced as well (boolean)
-        @keyparam autoClearShell flag indicating, that the interpreter window should
-            be cleared automatically (boolean)
-        @keyparam autoContinue flag indicating, that the debugger should not stop at
-            the first executable line (boolean)
+        @keyparam autoClearShell flag indicating, that the interpreter window
+            should be cleared automatically (boolean)
+        @keyparam autoContinue flag indicating, that the debugger should not
+            stop at the first executable line (boolean)
         @keyparam autoFork flag indicating the automatic fork mode (boolean)
-        @keyparam forkChild flag indicating to debug the child after forking (boolean)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
         """
         super().__init__(parent)
         self.setModal(True)
@@ -137,9 +140,10 @@
         """
         Public method to retrieve the data entered into this dialog.
         
-        @return a tuple of argv (string), workdir (string), environment (string),
-            exceptions flag (boolean), clear interpreter flag (boolean),
-            clear histories flag (boolean) and run in console flag (boolean)
+        @return a tuple of argv (string), workdir (string), environment
+            (string), exceptions flag (boolean), clear interpreter flag
+            (boolean), clear histories flag (boolean) and run in console
+            flag (boolean)
         """
         cmdLine = self.ui.cmdlineCombo.currentText()
         workdir = self.ui.workdirCombo.currentText()
@@ -155,13 +159,15 @@
         
     def getDebugData(self):
         """
-        Public method to retrieve the debug related data entered into this dialog.
+        Public method to retrieve the debug related data entered into this
+        dialog.
         
-        @return a tuple of a flag indicating, if the Python library should be traced
-            as well, a flag indicating, that the debugger should not stop at the
-            first executable line (boolean), a flag indicating, that the debugger
-            should fork automatically (boolean) and a flag indicating, that the
-            debugger should debug the child process after forking automatically (boolean)
+        @return a tuple of a flag indicating, if the Python library should be
+            traced as well, a flag indicating, that the debugger should not
+            stop at the first executable line (boolean), a flag indicating,
+            that the debugger should fork automatically (boolean) and a flag
+            indicating, that the debugger should debug the child process after
+            forking automatically (boolean)
         """
         if self.type == 0:
             return (self.ui.tracePythonCheckBox.isChecked(),
@@ -171,11 +177,13 @@
         
     def getRunData(self):
         """
-        Public method to retrieve the debug related data entered into this dialog.
+        Public method to retrieve the debug related data entered into this
+        dialog.
         
-        @return a tuple of a flag indicating, that the debugger should fork automatically
-            (boolean) and a flag indicating, that the debugger should debug the child
-            process after forking automatically (boolean)
+        @return a tuple of a flag indicating, that the debugger should fork
+            automatically (boolean) and a flag indicating, that the debugger
+            should debug the child process after forking automatically
+            (boolean)
         """
         if self.type == 1:
             return (self.ui.forkModeCheckBox.isChecked(),
@@ -183,7 +191,8 @@
         
     def getCoverageData(self):
         """
-        Public method to retrieve the coverage related data entered into this dialog.
+        Public method to retrieve the coverage related data entered into this
+        dialog.
         
         @return flag indicating erasure of coverage info (boolean)
         """
@@ -192,7 +201,8 @@
         
     def getProfilingData(self):
         """
-        Public method to retrieve the profiling related data entered into this dialog.
+        Public method to retrieve the profiling related data entered into this
+        dialog.
         
         @return flag indicating erasure of profiling info (boolean)
         """
--- a/Debugger/VariablesFilterDialog.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/VariablesFilterDialog.py	Sun Oct 06 19:00:04 2013 +0200
@@ -57,8 +57,8 @@
         """
         Public slot to retrieve the current selections.
         
-        @return A tuple of lists of integer values. The first list is the locals variables
-            filter, the second the globals variables filter.
+        @return A tuple of lists of integer values. The first list is the
+            locals variables filter, the second the globals variables filter.
         """
         lList = []
         gList = []
--- a/Debugger/VariablesViewer.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/VariablesViewer.py	Sun Oct 06 19:00:04 2013 +0200
@@ -8,8 +8,8 @@
 """
 
 from PyQt4.QtCore import Qt, QRegExp, qVersion
-from PyQt4.QtGui import QTreeWidget, QTreeWidgetItem, QApplication, QAbstractItemView, \
-    QMenu
+from PyQt4.QtGui import QTreeWidget, QTreeWidgetItem, QApplication, \
+    QAbstractItemView, QMenu
 from PyQt4.QtGui import QTextDocument   # __IGNORE_WARNING__
 
 from E5Gui.E5Application import e5App
@@ -76,8 +76,8 @@
         """
         Public method to return the data for the requested role.
         
-        This implementation changes the original behavior in a way, that the display
-        data is returned as the tooltip for column 1.
+        This implementation changes the original behavior in a way, that the
+        display data is returned as the tooltip for column 1.
         
         @param column column number (integer)
         @param role data role (Qt.ItemDataRole)
@@ -221,7 +221,8 @@
 
 class SpecialArrayElementVarItem(SpecialVarItem):
     """
-    Class implementing a QTreeWidgetItem that represents a special array variable node.
+    Class implementing a QTreeWidgetItem that represents a special array
+    variable node.
     """
     def __init__(self, parent, dvar, dvalue, dtype, frmnr, scope):
         """
@@ -234,7 +235,8 @@
         @param frmnr frame number (0 is the current frame) (int)
         @param scope flag indicating global (1) or local (0) variables
         """
-        SpecialVarItem.__init__(self, parent, dvar, dvalue, dtype, frmnr, scope)
+        SpecialVarItem.__init__(self, parent, dvar, dvalue, dtype, frmnr,
+                                scope)
         
         """
         Array elements have numbers as names, but the key must be
@@ -281,13 +283,16 @@
         """
         super().__init__(parent)
         
-        self.indicators = {'list': '[]', 'tuple': '()', 'dict': '{}',   # Python types
-                           'Array': '[]', 'Hash': '{}'}                # Ruby types
+        self.indicators = {'list': '[]', 'tuple': '()', 'dict': '{}',
+                           # Python types
+                           'Array': '[]', 'Hash': '{}'}
+                           # Ruby types
         
         self.rx_class = QRegExp('<.*(instance|object) at 0x.*>')
         self.rx_class2 = QRegExp('class .*')
         self.rx_class3 = QRegExp('<class .* at 0x.*>')
-        self.dvar_rx_class1 = QRegExp(r'<.*(instance|object) at 0x.*>(\[\]|\{\}|\(\))')
+        self.dvar_rx_class1 = QRegExp(
+            r'<.*(instance|object) at 0x.*>(\[\]|\{\}|\(\))')
         self.dvar_rx_class2 = QRegExp(r'<class .* at 0x.*>(\[\]|\{\}|\(\))')
         self.dvar_rx_array_element = QRegExp(r'^\d+$')
         self.dvar_rx_special_array_element = QRegExp(r'^\d+(\[\]|\{\}|\(\))$')
@@ -498,7 +503,8 @@
                     self.scrollToItem(citm, QAbstractItemView.PositionAtTop)
                 self.current = None
         elif self.__scrollToItem:
-            self.scrollToItem(self.__scrollToItem, QAbstractItemView.PositionAtTop)
+            self.scrollToItem(self.__scrollToItem,
+                              QAbstractItemView.PositionAtTop)
         
         self.resortEnabled = resortEnabled
         self.__resort()
@@ -511,7 +517,8 @@
         @param dvar variable name (string)
         @param dvalue value string (string)
         @param dtype type string (string)
-        @param isSpecial flag indicating that a special node should be generated (boolean)
+        @param isSpecial flag indicating that a special node should be
+            generated (boolean)
         @return The item that was generated (VariableItem).
         """
         if isSpecial and \
@@ -593,9 +600,8 @@
             dvtype = self.trUtf8(ConfigVarTypeDispStrings[i])
         except ValueError:
             if vtype == 'classobj':
-                dvtype = self.trUtf8(
-                    ConfigVarTypeDispStrings[ConfigVarTypeStrings.index('instance')]\
-                )
+                dvtype = self.trUtf8(ConfigVarTypeDispStrings[
+                    ConfigVarTypeStrings.index('instance')])
             else:
                 dvtype = vtype
         return dvtype
@@ -604,8 +610,8 @@
         """
         Protected method of QAbstractItemView.
         
-        Reimplemented to disable expanding/collapsing
-        of items when double-clicking. Instead the double-clicked entry is opened.
+        Reimplemented to disable expanding/collapsing of items when
+        double-clicking. Instead the double-clicked entry is opened.
         
         @param mouseEvent the mouse event object (QMouseEvent)
         """
@@ -682,7 +688,8 @@
         """
         Private slot to handle the expanded signal.
         
-        @param parentItem reference to the item being expanded (QTreeWidgetItem)
+        @param parentItem reference to the item being expanded
+            (QTreeWidgetItem)
         """
         self.expandItem(parentItem)
         self.__scrollToItem = parentItem
@@ -691,7 +698,8 @@
         """
         Public slot to handle the expanded signal.
         
-        @param parentItem reference to the item being expanded (QTreeWidgetItem)
+        @param parentItem reference to the item being expanded
+            (QTreeWidgetItem)
         """
         pathlist = self.__buildTreePath(parentItem)
         self.openItems.append(pathlist)
@@ -708,7 +716,8 @@
         """
         Public slot to handle the collapsed signal.
         
-        @param parentItem reference to the item being collapsed (QTreeWidgetItem)
+        @param parentItem reference to the item being collapsed
+            (QTreeWidgetItem)
         """
         pathlist = self.__buildTreePath(parentItem)
         self.openItems.remove(pathlist)
@@ -723,7 +732,8 @@
         Private method to resort the tree.
         """
         if self.resortEnabled:
-            self.sortItems(self.sortColumn(), self.header().sortIndicatorOrder())
+            self.sortItems(self.sortColumn(),
+                           self.header().sortIndicatorOrder())
     
     def handleResetUI(self):
         """
@@ -736,4 +746,5 @@
         """
         Private method to open the configuration dialog.
         """
-        e5App().getObject("UserInterface").showPreferences("debuggerGeneralPage")
+        e5App().getObject("UserInterface")\
+            .showPreferences("debuggerGeneralPage")
--- a/Debugger/WatchPointModel.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/WatchPointModel.py	Sun Oct 06 19:00:04 2013 +0200
@@ -156,7 +156,7 @@
         else:
             return False
     
-    ############################################################################
+    ###########################################################################
     
     def addWatchPoint(self, cond, special, properties):
         """
@@ -165,7 +165,8 @@
         @param cond expression of the watch expression (string)
         @param special special condition of the watch expression (string)
         @param properties properties of the watch expression
-            (tuple of temporary flag (bool), enabled flag (bool), ignore count (integer))
+            (tuple of temporary flag (bool), enabled flag (bool),
+            ignore count (integer))
         """
         wp = [cond, special] + list(properties)
         cnt = len(self.watchpoints)
@@ -181,7 +182,8 @@
         @param cond expression of the watch expression (string)
         @param special special condition of the watch expression (string)
         @param properties properties of the watch expression
-            (tuple of temporary flag (bool), enabled flag (bool), ignore count (integer))
+            (tuple of temporary flag (bool), enabled flag (bool),
+            ignore count (integer))
         """
         if index.isValid():
             row = index.row()
@@ -197,7 +199,8 @@
 
     def setWatchPointEnabledByIndex(self, index, enabled):
         """
-        Public method to set the enabled state of a watch expression given by index.
+        Public method to set the enabled state of a watch expression given by
+        index.
         
         @param index index of the watch expression (QModelIndex)
         @param enabled flag giving the enabled state (boolean)
@@ -224,7 +227,8 @@
 
     def deleteWatchPoints(self, idxList):
         """
-        Public method to delete a list of watch expressions given by their indexes.
+        Public method to delete a list of watch expressions given by their
+        indexes.
         
         @param idxList list of watch expression indexes (list of QModelIndex)
         """
@@ -252,8 +256,9 @@
         Public method to get the values of a watch expression given by index.
         
         @param index index of the watch expression (QModelIndex)
-        @return watch expression (list of six values (expression, special condition,
-            temporary flag, enabled flag, ignore count, index))
+        @return watch expression (list of six values (expression,
+            special condition, temporary flag, enabled flag, ignore count,
+            index))
         """
         if index.isValid():
             return self.watchpoints[index.row()][:]  # return a copy
@@ -262,7 +267,8 @@
 
     def getWatchPointIndex(self, cond, special=""):
         """
-        Public method to get the index of a watch expression given by expression.
+        Public method to get the index of a watch expression given by
+        expression.
         
         @param cond expression of the watch expression (string)
         @param special special condition of the watch expression (string)
--- a/Debugger/WatchPointViewer.py	Sun Oct 06 18:02:21 2013 +0200
+++ b/Debugger/WatchPointViewer.py	Sun Oct 06 19:00:04 2013 +0200
@@ -8,8 +8,8 @@
 """
 
 from PyQt4.QtCore import Qt, QModelIndex, qVersion
-from PyQt4.QtGui import QTreeView, QAbstractItemView, QMenu, QSortFilterProxyModel, \
-    QHeaderView, QItemSelectionModel, QDialog
+from PyQt4.QtGui import QTreeView, QAbstractItemView, QMenu, \
+    QSortFilterProxyModel, QHeaderView, QItemSelectionModel, QDialog
 
 from E5Gui.E5Application import e5App
 from E5Gui import E5MessageBox
@@ -21,8 +21,8 @@
     """
     Class implementing the watch expression viewer widget.
     
-    Watch expressions will be shown with all their details. They can be modified through
-    the context menu of this widget.
+    Watch expressions will be shown with all their details. They can be
+    modified through the context menu of this widget.
     """
     def __init__(self, parent=None):
         """
@@ -83,7 +83,8 @@
         
     def __resizeColumns(self):
         """
-        Private slot to resize the view when items get added, edited or deleted.
+        Private slot to resize the view when items get added, edited or
+        deleted.
         """
         self.header().resizeSections(QHeaderView.ResizeToContents)
         self.header().setStretchLastSection(True)
@@ -140,13 +141,16 @@
         self.menu.addAction(self.trUtf8("Edit..."), self.__editWatchPoint)
         self.menu.addSeparator()
         self.menu.addAction(self.trUtf8("Enable"), self.__enableWatchPoint)
-        self.menu.addAction(self.trUtf8("Enable all"), self.__enableAllWatchPoints)
+        self.menu.addAction(self.trUtf8("Enable all"),
+                            self.__enableAllWatchPoints)
         self.menu.addSeparator()
         self.menu.addAction(self.trUtf8("Disable"), self.__disableWatchPoint)
-        self.menu.addAction(self.trUtf8("Disable all"), self.__disableAllWatchPoints)
+        self.menu.addAction(self.trUtf8("Disable all"),
+                            self.__disableAllWatchPoints)
         self.menu.addSeparator()
         self.menu.addAction(self.trUtf8("Delete"), self.__deleteWatchPoint)
-        self.menu.addAction(self.trUtf8("Delete all"), self.__deleteAllWatchPoints)
+        self.menu.addAction(self.trUtf8("Delete all"),
+                            self.__deleteAllWatchPoints)
         self.menu.addSeparator()
         self.menu.addAction(self.trUtf8("Configure..."), self.__configure)
 
@@ -155,13 +159,13 @@
         self.backMenu.addAction(self.trUtf8("Add"), self.__addWatchPoint)
         self.backMenuActions["EnableAll"] = \
             self.backMenu.addAction(self.trUtf8("Enable all"),
-                self.__enableAllWatchPoints)
+                                    self.__enableAllWatchPoints)
         self.backMenuActions["DisableAll"] = \
             self.backMenu.addAction(self.trUtf8("Disable all"),
-                self.__disableAllWatchPoints)
+                                    self.__disableAllWatchPoints)
         self.backMenuActions["DeleteAll"] = \
             self.backMenu.addAction(self.trUtf8("Delete all"),
-                self.__deleteAllWatchPoints)
+                                    self.__deleteAllWatchPoints)
         self.backMenu.addSeparator()
         self.backMenu.addAction(self.trUtf8("Configure..."), self.__configure)
         self.backMenu.aboutToShow.connect(self.__showBackMenu)
@@ -170,16 +174,19 @@
         self.multiMenu.addAction(self.trUtf8("Add"), self.__addWatchPoint)
         self.multiMenu.addSeparator()
         self.multiMenu.addAction(self.trUtf8("Enable selected"),
-            self.__enableSelectedWatchPoints)
-        self.multiMenu.addAction(self.trUtf8("Enable all"), self.__enableAllWatchPoints)
+                                 self.__enableSelectedWatchPoints)
+        self.multiMenu.addAction(self.trUtf8("Enable all"),
+                                 self.__enableAllWatchPoints)
         self.multiMenu.addSeparator()
         self.multiMenu.addAction(self.trUtf8("Disable selected"),
-            self.__disableSelectedWatchPoints)
-        self.multiMenu.addAction(self.trUtf8("Disable all"), self.__disableAllWatchPoints)
+                                 self.__disableSelectedWatchPoints)
+        self.multiMenu.addAction(self.trUtf8("Disable all"),
+                                 self.__disableAllWatchPoints)
         self.multiMenu.addSeparator()
         self.multiMenu.addAction(self.trUtf8("Delete selected"),
-            self.__deleteSelectedWatchPoints)
-        self.multiMenu.addAction(self.trUtf8("Delete all"), self.__deleteAllWatchPoints)
+                                 self.__deleteSelectedWatchPoints)
+        self.multiMenu.addAction(self.trUtf8("Delete all"),
+                                 self.__deleteAllWatchPoints)
         self.multiMenu.addSeparator()
         self.multiMenu.addAction(self.trUtf8("Configure..."), self.__configure)
     
@@ -210,7 +217,8 @@
         for index in self.selectedIndexes():
             self.__setRowSelected(index, False)
     
-    def __findDuplicates(self, cond, special, showMessage=False, index=QModelIndex()):
+    def __findDuplicates(self, cond, special, showMessage=False,
+                         index=QModelIndex()):
         """
         Private method to check, if an entry already exists.
         
@@ -218,20 +226,23 @@
         @param special special condition to check (string)
         @param showMessage flag indicating a message should be shown,
             if a duplicate entry is found (boolean)
-        @param index index that should not be considered duplicate (QModelIndex)
+        @param index index that should not be considered duplicate
+            (QModelIndex)
         @return flag indicating a duplicate entry (boolean)
         """
         idx = self.__model.getWatchPointIndex(cond, special)
-        duplicate = idx.isValid() and idx.internalPointer() != index.internalPointer()
+        duplicate = idx.isValid() and \
+            idx.internalPointer() != index.internalPointer()
         if showMessage and duplicate:
             if not special:
                 msg = self.trUtf8("""<p>A watch expression '<b>{0}</b>'"""
                                   """ already exists.</p>""")\
                         .format(Utilities.html_encode(cond))
             else:
-                msg = self.trUtf8("""<p>A watch expression '<b>{0}</b>'"""
-                                  """ for the variable <b>{1}</b> already exists.</p>""")\
-                        .format(special, Utilities.html_encode(cond))
+                msg = self.trUtf8(
+                    """<p>A watch expression '<b>{0}</b>'"""
+                    """ for the variable <b>{1}</b> already exists.</p>""")\
+                    .format(special, Utilities.html_encode(cond))
             E5MessageBox.warning(self,
                 self.trUtf8("Watch expression already exists"),
                 msg)
@@ -247,7 +258,8 @@
         if dlg.exec_() == QDialog.Accepted:
             cond, temp, enabled, ignorecount, special = dlg.getData()
             if not self.__findDuplicates(cond, special, True):
-                self.__model.addWatchPoint(cond, special, (temp, enabled, ignorecount))
+                self.__model.addWatchPoint(cond, special,
+                                           (temp, enabled, ignorecount))
                 self.__resizeColumns()
                 self.__resort()
 
@@ -297,7 +309,8 @@
         """
         Private method to set the enabled status of a watch expression.
         
-        @param index index of watch expression to be enabled/disabled (QModelIndex)
+        @param index index of watch expression to be enabled/disabled
+            (QModelIndex)
         @param enabled flag indicating the enabled status to be set (boolean)
         """
         sindex = self.__toSourceIndex(index)
@@ -315,7 +328,8 @@
 
     def __enableAllWatchPoints(self):
         """
-        Private slot to handle the enable all watch expressions context menu entry.
+        Private slot to handle the enable all watch expressions context menu
+        entry.
         """
         index = self.model().index(0, 0)
         while index.isValid():
@@ -326,7 +340,8 @@
 
     def __enableSelectedWatchPoints(self):
         """
-        Private slot to handle the enable selected watch expressions context menu entry.
+        Private slot to handle the enable selected watch expressions context
+        menu entry.
         """
         for index in self.selectedIndexes():
             if index.column() == 0:
@@ -345,7 +360,8 @@
 
     def __disableAllWatchPoints(self):
         """
-        Private slot to handle the disable all watch expressions context menu entry.
+        Private slot to handle the disable all watch expressions context menu
+        entry.
         """
         index = self.model().index(0, 0)
         while index.isValid():
@@ -356,7 +372,8 @@
 
     def __disableSelectedWatchPoints(self):
         """
-        Private slot to handle the disable selected watch expressions context menu entry.
+        Private slot to handle the disable selected watch expressions context
+        menu entry.
         """
         for index in self.selectedIndexes():
             if index.column() == 0:
@@ -375,13 +392,15 @@
         
     def __deleteAllWatchPoints(self):
         """
-        Private slot to handle the delete all watch expressions context menu entry.
+        Private slot to handle the delete all watch expressions context menu
+        entry.
         """
         self.__model.deleteAll()
 
     def __deleteSelectedWatchPoints(self):
         """
-        Private slot to handle the delete selected watch expressions context menu entry.
+        Private slot to handle the delete selected watch expressions context
+        menu entry.
         """
         idxList = []
         for index in self.selectedIndexes():
@@ -417,4 +436,5 @@
         """
         Private method to open the configuration dialog.
         """
-        e5App().getObject("UserInterface").showPreferences("debuggerGeneralPage")
+        e5App().getObject("UserInterface")\
+            .showPreferences("debuggerGeneralPage")

eric ide

mercurial