Unified the Python2 and Python3 debugger interfaces.

Sat, 26 Aug 2017 19:26:07 +0200

author
Detlev Offenbach <detlev@die-offenbachs.de>
date
Sat, 26 Aug 2017 19:26:07 +0200
changeset 5850
7fae79975686
parent 5849
512001065055
child 5851
8f8b264e5d5f

Unified the Python2 and Python3 debugger interfaces.

APIs/Python3/eric6.api file | annotate | diff | comparison | revisions
APIs/Python3/eric6.bas file | annotate | diff | comparison | revisions
Debugger/DebugServer.py file | annotate | diff | comparison | revisions
Debugger/DebuggerInterfaceNone.py file | annotate | diff | comparison | revisions
Debugger/DebuggerInterfacePython.py file | annotate | diff | comparison | revisions
Debugger/DebuggerInterfacePython2.py file | annotate | diff | comparison | revisions
Debugger/DebuggerInterfacePython3.py file | annotate | diff | comparison | revisions
Documentation/Help/source.qch file | annotate | diff | comparison | revisions
Documentation/Help/source.qhp file | annotate | diff | comparison | revisions
Documentation/Source/eric6.Debugger.DebugServer.html file | annotate | diff | comparison | revisions
Documentation/Source/eric6.Debugger.DebuggerInterfaceNone.html file | annotate | diff | comparison | revisions
Documentation/Source/eric6.Debugger.DebuggerInterfacePython.html file | annotate | diff | comparison | revisions
Documentation/Source/eric6.Debugger.DebuggerInterfacePython2.html file | annotate | diff | comparison | revisions
Documentation/Source/eric6.Debugger.DebuggerInterfacePython3.html file | annotate | diff | comparison | revisions
Documentation/Source/index-eric6.Debugger.html file | annotate | diff | comparison | revisions
changelog file | annotate | diff | comparison | revisions
eric6.e4p file | annotate | diff | comparison | revisions
i18n/eric6_cs.ts file | annotate | diff | comparison | revisions
i18n/eric6_de.qm file | annotate | diff | comparison | revisions
i18n/eric6_de.ts file | annotate | diff | comparison | revisions
i18n/eric6_empty.ts file | annotate | diff | comparison | revisions
i18n/eric6_en.ts file | annotate | diff | comparison | revisions
i18n/eric6_es.ts file | annotate | diff | comparison | revisions
i18n/eric6_fr.ts file | annotate | diff | comparison | revisions
i18n/eric6_it.ts file | annotate | diff | comparison | revisions
i18n/eric6_pt.ts file | annotate | diff | comparison | revisions
i18n/eric6_ru.ts file | annotate | diff | comparison | revisions
i18n/eric6_tr.ts file | annotate | diff | comparison | revisions
i18n/eric6_zh_CN.ts file | annotate | diff | comparison | revisions
--- a/APIs/Python3/eric6.api	Sat Aug 26 17:10:43 2017 +0200
+++ b/APIs/Python3/eric6.api	Sat Aug 26 19:26:07 2017 +0200
@@ -430,7 +430,7 @@
 eric6.Debugger.DebugServer.DebugServer.passiveDebugStarted?7
 eric6.Debugger.DebugServer.DebugServer.passiveStartUp?4(fn, exc)
 eric6.Debugger.DebugServer.DebugServer.preferencesChanged?4()
-eric6.Debugger.DebugServer.DebugServer.registerDebuggerInterface?4(name, getRegistryData)
+eric6.Debugger.DebugServer.DebugServer.registerDebuggerInterface?4(interfaceName, getRegistryData)
 eric6.Debugger.DebugServer.DebugServer.remoteBanner?4()
 eric6.Debugger.DebugServer.DebugServer.remoteBreakpoint?4(fn, line, setBreakpoint, cond=None, temp=False)
 eric6.Debugger.DebugServer.DebugServer.remoteCapabilities?4()
@@ -480,7 +480,7 @@
 eric6.Debugger.DebugServer.DebugServer.signalClientVariables?4(scope, variables)
 eric6.Debugger.DebugServer.DebugServer.signalClientWatchConditionError?4(condition)
 eric6.Debugger.DebugServer.DebugServer.startClient?4(unplanned=True, clType=None, forProject=False, runInConsole=False)
-eric6.Debugger.DebugServer.DebugServer.unregisterDebuggerInterface?4(name)
+eric6.Debugger.DebugServer.DebugServer.unregisterDebuggerInterface?4(interfaceName)
 eric6.Debugger.DebugServer.DebugServer.utFinished?7
 eric6.Debugger.DebugServer.DebugServer.utPrepared?7
 eric6.Debugger.DebugServer.DebugServer.utStartTest?7
@@ -583,90 +583,49 @@
 eric6.Debugger.DebuggerInterfaceNone.DebuggerInterfaceNone?1(debugServer, passive)
 eric6.Debugger.DebuggerInterfaceNone.createDebuggerInterfaceNone?4(debugServer, passive)
 eric6.Debugger.DebuggerInterfaceNone.getRegistryData?4()
-eric6.Debugger.DebuggerInterfacePython2.ClientDefaultCapabilities?7
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.flush?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.getClientCapabilities?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.isConnected?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.newConnection?4(sock)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteBanner?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteBreakpoint?4(fn, line, setBreakpoint, cond=None, temp=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteBreakpointEnable?4(fn, line, enable)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteBreakpointIgnore?4(fn, line, count)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteCapabilities?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteClientSetFilter?4(scope, filterStr)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteClientVariable?4(scope, filterList, var, framenr=0)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteClientVariables?4(scope, filterList, framenr=0)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteCompletion?4(text)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteContinue?4(special=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteCoverage?4(fn, argv, wd, erase=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteEnvironment?4(env)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteLoad?4(fn, argv, wd, traceInterpreter=False, autoContinue=True, autoFork=False, forkChild=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteMoveIP?4(line)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteProfile?4(fn, argv, wd, erase=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteRawInput?4(s)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteRun?4(fn, argv, wd, autoFork=False, forkChild=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteSetThread?4(tid)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteStatement?4(stmt)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteStep?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteStepOut?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteStepOver?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteStepQuit?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteThreadList?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteUTPrepare?4(fn, tn, tfn, failed, cov, covname, coverase)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteUTRun?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteUTStop?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteWatchpoint?4(cond, setWatch, temp=False)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteWatchpointEnable?4(cond, enable)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.remoteWatchpointIgnore?4(cond, count)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.setCallTraceEnabled?4(on)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.shutdown?4()
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.startRemote?4(port, runInConsole)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2.startRemoteForProject?4(port, runInConsole)
-eric6.Debugger.DebuggerInterfacePython2.DebuggerInterfacePython2?1(debugServer, passive)
-eric6.Debugger.DebuggerInterfacePython2.createDebuggerInterfacePython2?4(debugServer, passive)
-eric6.Debugger.DebuggerInterfacePython2.getRegistryData?4()
-eric6.Debugger.DebuggerInterfacePython3.ClientDefaultCapabilities?7
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.flush?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.getClientCapabilities?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.isConnected?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.newConnection?4(sock)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteBanner?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteBreakpoint?4(fn, line, setBreakpoint, cond=None, temp=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteBreakpointEnable?4(fn, line, enable)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteBreakpointIgnore?4(fn, line, count)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteCapabilities?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteClientSetFilter?4(scope, filterStr)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteClientVariable?4(scope, filterList, var, framenr=0)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteClientVariables?4(scope, filterList, framenr=0)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteCompletion?4(text)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteContinue?4(special=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteCoverage?4(fn, argv, wd, erase=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteEnvironment?4(env)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteLoad?4(fn, argv, wd, traceInterpreter=False, autoContinue=True, autoFork=False, forkChild=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteMoveIP?4(line)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteProfile?4(fn, argv, wd, erase=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteRawInput?4(s)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteRun?4(fn, argv, wd, autoFork=False, forkChild=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteSetThread?4(tid)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteStatement?4(stmt)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteStep?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteStepOut?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteStepOver?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteStepQuit?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteThreadList?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteUTPrepare?4(fn, tn, tfn, failed, cov, covname, coverase)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteUTRun?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteUTStop?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteWatchpoint?4(cond, setWatch, temp=False)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteWatchpointEnable?4(cond, enable)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.remoteWatchpointIgnore?4(cond, count)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.setCallTraceEnabled?4(on)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.shutdown?4()
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.startRemote?4(port, runInConsole)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3.startRemoteForProject?4(port, runInConsole)
-eric6.Debugger.DebuggerInterfacePython3.DebuggerInterfacePython3?1(debugServer, passive)
-eric6.Debugger.DebuggerInterfacePython3.createDebuggerInterfacePython3?4(debugServer, passive)
-eric6.Debugger.DebuggerInterfacePython3.getRegistryData?4()
+eric6.Debugger.DebuggerInterfacePython.ClientDefaultCapabilities?7
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.flush?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.getClientCapabilities?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.isConnected?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.newConnection?4(sock)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteBanner?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteBreakpoint?4(fn, line, setBreakpoint, cond=None, temp=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteBreakpointEnable?4(fn, line, enable)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteBreakpointIgnore?4(fn, line, count)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteCapabilities?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteClientSetFilter?4(scope, filterStr)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteClientVariable?4(scope, filterList, var, framenr=0)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteClientVariables?4(scope, filterList, framenr=0)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteCompletion?4(text)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteContinue?4(special=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteCoverage?4(fn, argv, wd, erase=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteEnvironment?4(env)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteLoad?4(fn, argv, wd, traceInterpreter=False, autoContinue=True, autoFork=False, forkChild=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteMoveIP?4(line)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteProfile?4(fn, argv, wd, erase=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteRawInput?4(s)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteRun?4(fn, argv, wd, autoFork=False, forkChild=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteSetThread?4(tid)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteStatement?4(stmt)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteStep?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteStepOut?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteStepOver?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteStepQuit?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteThreadList?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteUTPrepare?4(fn, tn, tfn, failed, cov, covname, coverase)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteUTRun?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteUTStop?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteWatchpoint?4(cond, setWatch, temp=False)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteWatchpointEnable?4(cond, enable)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.remoteWatchpointIgnore?4(cond, count)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.setCallTraceEnabled?4(on)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.shutdown?4()
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.startRemote?4(port, runInConsole)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython.startRemoteForProject?4(port, runInConsole)
+eric6.Debugger.DebuggerInterfacePython.DebuggerInterfacePython?1(debugServer, passive, pythonVariant)
+eric6.Debugger.DebuggerInterfacePython.createDebuggerInterfacePython2?4(debugServer, passive)
+eric6.Debugger.DebuggerInterfacePython.createDebuggerInterfacePython3?4(debugServer, passive)
+eric6.Debugger.DebuggerInterfacePython.getRegistryData?4()
 eric6.Debugger.EditBreakpointDialog.EditBreakpointDialog.getAddData?4()
 eric6.Debugger.EditBreakpointDialog.EditBreakpointDialog.getData?4()
 eric6.Debugger.EditBreakpointDialog.EditBreakpointDialog.on_filenamePicker_editTextChanged?4(fn)
--- a/APIs/Python3/eric6.bas	Sat Aug 26 17:10:43 2017 +0200
+++ b/APIs/Python3/eric6.bas	Sat Aug 26 19:26:07 2017 +0200
@@ -118,8 +118,7 @@
 DebugViewer QWidget
 DebuggerGeneralPage ConfigurationPageBase Ui_DebuggerGeneralPage
 DebuggerInterfaceNone QObject
-DebuggerInterfacePython2 QObject
-DebuggerInterfacePython3 QObject
+DebuggerInterfacePython QObject
 DebuggerPropertiesDialog QDialog Ui_DebuggerPropertiesDialog
 DebuggerPropertiesReader XMLStreamReaderBase
 DebuggerPropertiesWriter XMLStreamWriterBase
--- a/Debugger/DebugServer.py	Sat Aug 26 17:10:43 2017 +0200
+++ b/Debugger/DebugServer.py	Sat Aug 26 19:26:07 2017 +0200
@@ -30,11 +30,8 @@
 import Utilities
 
 
-# TODO: change this to a list of debugger interfaces and unite the two Python
-#       variants because they are nearly identical
 DebuggerInterfaces = {
-    "Python2": "DebuggerInterfacePython2",
-    "Python3": "DebuggerInterfacePython3",
+    "Python": "DebuggerInterfacePython",
     "None": "DebuggerInterfaceNone",
 }
 
@@ -165,12 +162,15 @@
         """
         super(DebugServer, self).__init__()
         
+        self.__debuggerInterfaces = {}
+        # the interface name is the key, a function to get the
+        # registration data is the value
         self.__debuggerInterfaceRegistry = {}
         # the client language is the key, a list containing the client
-        # capabilities, the list of associated file extensions, a
+        # capabilities, a list of associated file extensions, a
         # function reference to create the debugger interface (see
-        # __createDebuggerInterface() below) and a function to be called
-        # to get the registration data as values
+        # __createDebuggerInterface() below) and the interface name is
+        # the value
         
         # create our models
         self.breakpointModel = BreakPointModel(self)
@@ -294,23 +294,21 @@
         """
         Public slot to handle the preferencesChanged signal.
         """
-        # TODO: just build a set of registry data functions and call
-        #       registerDebuggerInterface with each of them
         registeredInterfaces = {}
-        for language in self.__debuggerInterfaceRegistry:
-            registeredInterfaces[language] = \
-                self.__debuggerInterfaceRegistry[language][-1]
-            # last entry is the registry data function
+        for interfaceName in self.__debuggerInterfaces:
+            registeredInterfaces[interfaceName] = \
+                self.__debuggerInterfaces[interfaceName]
         
+        self.__debuggerInterfaces = {}
         self.__debuggerInterfaceRegistry = {}
-        for language, getRegistryData in registeredInterfaces.items():
-            self.registerDebuggerInterface(language, getRegistryData)
+        for interfaceName, getRegistryData in registeredInterfaces.items():
+            self.registerDebuggerInterface(interfaceName, getRegistryData)
         
-    def registerDebuggerInterface(self, name, getRegistryData):
+    def registerDebuggerInterface(self, interfaceName, getRegistryData):
         """
         Public method to register a debugger interface.
         
-        @param name name of the debugger interface
+        @param interfaceName name of the debugger interface
         @type str
         @param getRegistryData reference to a function to be called
             to get the debugger interface details. This method shall
@@ -319,9 +317,7 @@
             to create the debugger interface (see __createDebuggerInterface())
         @type function
         """
-        # TODO: remove the 'name' parameter and move the check below against
-        #       clientLanguage
-        if name in self.__debuggerInterfaceRegistry:
+        if interfaceName in self.__debuggerInterfaces:
             E5MessageBox.warning(
                 None,
                 self.tr("Register Debugger Interface"),
@@ -329,24 +325,31 @@
                         """ been registered. Ignoring this request.</p>"""))
             return
         
-        # TODO: change getRegistryData to return a list of registry entries
-        clientLanguage, clientCapabilities, clientExtensions, \
-            interfaceCreator = getRegistryData()
-        if clientLanguage:
-            self.__debuggerInterfaceRegistry[clientLanguage] = \
-                [clientCapabilities, clientExtensions, interfaceCreator,
-                 getRegistryData]
+        registryDataList = getRegistryData()
+        if registryDataList:
+            self.__debuggerInterfaces[interfaceName] = getRegistryData
+            for clientLanguage, clientCapabilities, clientExtensions, \
+                interfaceCreator in registryDataList:
+                    self.__debuggerInterfaceRegistry[clientLanguage] = [
+                        clientCapabilities, clientExtensions, interfaceCreator,
+                        interfaceName]
         
-    def unregisterDebuggerInterface(self, name):
+    def unregisterDebuggerInterface(self, interfaceName):
         """
         Public method to unregister a debugger interface.
         
-        @param name name of the debugger interface
+        @param interfaceName interfaceName of the debugger interface
         @type str
         """
-        # TODO: change name to a list of names
-        if name in self.__debuggerInterfaceRegistry:
-            del self.__debuggerInterfaceRegistry[name]
+        if interfaceName in self.__debuggerInterfaces:
+            clientLanguages = []
+            for clientLanguage, registryData in \
+                    self.__debuggerInterfaceRegistry.items():
+                if interfaceName == registryData[-1]:
+                    clientLanguages.append(clientLanguage)
+            for clientLanguage in clientLanguages:
+                del self.__debuggerInterfaceRegistry[clientLanguage]
+            del self.__debuggerInterfaces[interfaceName]
         
     def __findLanguageForExtension(self, ext):
         """
@@ -367,7 +370,6 @@
         """
         Private method to register the available internal debugger interfaces.
         """
-        # TODO: apply DebuggerInterfaces being a list
         for name, interface in DebuggerInterfaces.items():
             modName = "Debugger.{0}".format(interface)
             mod = __import__(modName)
@@ -375,7 +377,6 @@
             for comp in components[1:]:
                 mod = getattr(mod, comp)
             
-            # TODO: remove name parameter
             self.registerDebuggerInterface(name, mod.getRegistryData)
         
     def getSupportedLanguages(self, shellOnly=False):
--- a/Debugger/DebuggerInterfaceNone.py	Sat Aug 26 17:10:43 2017 +0200
+++ b/Debugger/DebuggerInterfaceNone.py	Sat Aug 26 19:26:07 2017 +0200
@@ -409,18 +409,19 @@
     @param passive flag indicating passive connection mode
     @type bool
     @return instantiated debugger interface
-    @rtype DebuggerInterfacePython
+    @rtype DebuggerInterfaceNone
     """
     return DebuggerInterfaceNone(debugServer, passive)
 
 
 def getRegistryData():
     """
-    Module functionto get characterizing data for the debugger interface.
+    Module function to get characterizing data for the debugger interface.
     
-    @return tuple containing  client type, client capabilities, client file
-        type associations and reference to creation function
-    @rtype tuple of (str, int, list of str, function)
+    @return list of tuples containing the client type, the client capabilities,
+        the client file type associations and a reference to the creation
+        function
+    @rtype list of tuple of (str, int, list of str, function)
     """
-    return ["None", ClientDefaultCapabilities, ClientTypeAssociations,
-            createDebuggerInterfaceNone]
+    return [("None", ClientDefaultCapabilities, ClientTypeAssociations,
+            createDebuggerInterfaceNone)]
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Debugger/DebuggerInterfacePython.py	Sat Aug 26 19:26:07 2017 +0200
@@ -0,0 +1,1156 @@
+# -*- coding: utf-8 -*-
+
+# Copyright (c) 2009 - 2017 Detlev Offenbach <detlev@die-offenbachs.de>
+#
+
+"""
+Module implementing the Python3 debugger interface for the debug server.
+"""
+
+from __future__ import unicode_literals
+
+import sys
+import os
+
+from PyQt5.QtCore import QObject, QTextCodec, QProcess, QProcessEnvironment, \
+    QTimer
+from PyQt5.QtWidgets import QInputDialog
+
+from E5Gui.E5Application import e5App
+from E5Gui import E5MessageBox
+
+from . import DebugClientCapabilities
+
+import Preferences
+import Utilities
+
+from eric6config import getConfig
+
+
+ClientDefaultCapabilities = DebugClientCapabilities.HasAll
+
+
+class DebuggerInterfacePython(QObject):
+    """
+    Class implementing the debugger interface for the debug server for Python 2
+    and Python 3.
+    """
+    def __init__(self, debugServer, passive, pythonVariant):
+        """
+        Constructor
+        
+        @param debugServer reference to the debug server
+        @type DebugServer
+        @param passive flag indicating passive connection mode
+        @type bool
+        @param pythonVariant Python variant to instantiate for
+        @type str (one of Python2 or Python3)
+        """
+        super(DebuggerInterfacePython, self).__init__()
+        
+        self.__isNetworked = True
+        self.__autoContinue = False
+        
+        self.debugServer = debugServer
+        self.passive = passive
+        self.process = None
+        self.__variant = pythonVariant
+        
+        self.qsock = None
+        self.queue = []
+        
+        # set default values for capabilities of clients
+        self.clientCapabilities = ClientDefaultCapabilities
+        
+        # set translation function
+        self.translate = self.__identityTranslation
+        
+        self.codec = QTextCodec.codecForName(
+            str(Preferences.getSystem("StringEncoding")))
+        
+        if passive:
+            # set translation function
+            if Preferences.getDebugger("PathTranslation"):
+                self.translateRemote = \
+                    Preferences.getDebugger("PathTranslationRemote")
+                self.translateLocal = \
+                    Preferences.getDebugger("PathTranslationLocal")
+                self.translate = self.__remoteTranslation
+            else:
+                self.translate = self.__identityTranslation
+        
+        # attribute to remember the name of the executed script
+        self.__scriptName = ""
+
+    def __identityTranslation(self, fn, remote2local=True):
+        """
+        Private method to perform the identity path translation.
+        
+        @param fn filename to be translated (string)
+        @param remote2local flag indicating the direction of translation
+            (False = local to remote, True = remote to local [default])
+        @return translated filename (string)
+        """
+        return fn
+        
+    def __remoteTranslation(self, fn, remote2local=True):
+        """
+        Private method to perform the path translation.
+        
+        @param fn filename to be translated (string)
+        @param remote2local flag indicating the direction of translation
+            (False = local to remote, True = remote to local [default])
+        @return translated filename (string)
+        """
+        if remote2local:
+            return fn.replace(self.translateRemote, self.translateLocal)
+        else:
+            return fn.replace(self.translateLocal, self.translateRemote)
+        
+    def __startProcess(self, program, arguments, environment=None):
+        """
+        Private method to start the debugger client process.
+        
+        @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)
+        @return the process object (QProcess) or None
+        """
+        proc = QProcess()
+        if environment is not None:
+            env = QProcessEnvironment()
+            for key, value in list(environment.items()):
+                env.insert(key, value)
+            proc.setProcessEnvironment(env)
+        args = []
+        for arg in arguments:
+            args.append(arg)
+        proc.start(program, args)
+        if not proc.waitForStarted(10000):
+            proc = None
+        
+        return proc
+        
+    def startRemote(self, port, runInConsole):
+        """
+        Public method to start a remote Python interpreter.
+        
+        @param port portnumber the debug server is listening on (integer)
+        @param runInConsole flag indicating to start the debugger in a
+            console window (boolean)
+        @return client process object (QProcess), a flag to indicate
+            a network connection (boolean) and the name of the interpreter
+            in case of a local execution (string)
+        """
+        if self.__variant == "Python2":
+            interpreter = Preferences.getDebugger("PythonInterpreter")
+        else:
+            interpreter = Preferences.getDebugger("Python3Interpreter")
+        if interpreter == "":
+            E5MessageBox.critical(
+                None,
+                self.tr("Start Debugger"),
+                self.tr(
+                    """<p>No {0} interpreter configured.</p>""")
+                .format(self.__variant))
+            return None, False, ""
+        
+        if self.__variant == "Python2":
+            debugClientType = Preferences.getDebugger("DebugClientType")
+        else:
+            debugClientType = Preferences.getDebugger("DebugClientType3")
+        if debugClientType == "standard":
+            debugClient = os.path.join(getConfig('ericDir'),
+                                       "DebugClients", "Python",
+                                       "DebugClient.py")
+        else:
+            if self.__variant == "Python2":
+                debugClient = Preferences.getDebugger("DebugClient")
+            else:
+                debugClient = Preferences.getDebugger("DebugClient3")
+            if debugClient == "":
+                debugClient = os.path.join(sys.path[0],
+                                           "DebugClients", "Python",
+                                           "DebugClient.py")
+        
+        if self.__variant == "Python2":
+            redirect = str(Preferences.getDebugger("PythonRedirect"))
+            noencoding = Preferences.getDebugger("PythonNoEncoding") and \
+                '--no-encoding' or ''
+        else:
+            redirect = str(Preferences.getDebugger("Python3Redirect"))
+            noencoding = Preferences.getDebugger("Python3NoEncoding") and \
+                '--no-encoding' or ''
+        
+        if Preferences.getDebugger("RemoteDbgEnabled"):
+            ipaddr = self.debugServer.getHostAddress(False)
+            rexec = Preferences.getDebugger("RemoteExecution")
+            rhost = Preferences.getDebugger("RemoteHost")
+            if rhost == "":
+                rhost = "localhost"
+            if rexec:
+                args = Utilities.parseOptionString(rexec) + \
+                    [rhost, interpreter, debugClient,
+                        noencoding, str(port), redirect, ipaddr]
+                args[0] = Utilities.getExecutablePath(args[0])
+                process = self.__startProcess(args[0], args[1:])
+                if process is None:
+                    E5MessageBox.critical(
+                        None,
+                        self.tr("Start Debugger"),
+                        self.tr(
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
+                
+                # set translation function
+                if Preferences.getDebugger("PathTranslation"):
+                    self.translateRemote = \
+                        Preferences.getDebugger("PathTranslationRemote")
+                    self.translateLocal = \
+                        Preferences.getDebugger("PathTranslationLocal")
+                    self.translate = self.__remoteTranslation
+                else:
+                    self.translate = self.__identityTranslation
+                return process, self.__isNetworked, ""
+        
+        # set translation function
+        self.translate = self.__identityTranslation
+        
+        # setup the environment for the debugger
+        if Preferences.getDebugger("DebugEnvironmentReplace"):
+            clientEnv = {}
+        else:
+            clientEnv = os.environ.copy()
+        envlist = Utilities.parseEnvironmentString(
+            Preferences.getDebugger("DebugEnvironment"))
+        for el in envlist:
+            try:
+                key, value = el.split('=', 1)
+                if value.startswith('"') or value.startswith("'"):
+                    value = value[1:-1]
+                clientEnv[str(key)] = str(value)
+            except ValueError:
+                pass
+        
+        ipaddr = self.debugServer.getHostAddress(True)
+        if runInConsole or Preferences.getDebugger("ConsoleDbgEnabled"):
+            ccmd = Preferences.getDebugger("ConsoleDbgCommand")
+            if ccmd:
+                args = Utilities.parseOptionString(ccmd) + \
+                    [interpreter, os.path.abspath(debugClient),
+                        noencoding, str(port), '0', ipaddr]
+                args[0] = Utilities.getExecutablePath(args[0])
+                process = self.__startProcess(args[0], args[1:], clientEnv)
+                if process is None:
+                    E5MessageBox.critical(
+                        None,
+                        self.tr("Start Debugger"),
+                        self.tr(
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
+                return process, self.__isNetworked, interpreter
+        
+        process = self.__startProcess(
+            interpreter,
+            [debugClient, noencoding, str(port), redirect, ipaddr],
+            clientEnv)
+        if process is None:
+            E5MessageBox.critical(
+                None,
+                self.tr("Start Debugger"),
+                self.tr(
+                    """<p>The debugger backend could not be started.</p>"""))
+        return process, self.__isNetworked, interpreter
+
+    def startRemoteForProject(self, port, runInConsole):
+        """
+        Public method to start a remote Python interpreter for a project.
+        
+        @param port portnumber the debug server is listening on (integer)
+        @param runInConsole flag indicating to start the debugger in a
+            console window (boolean)
+        @return client process object (QProcess), a flag to indicate
+            a network connection (boolean) and the name of the interpreter
+            in case of a local execution (string)
+        """
+        project = e5App().getObject("Project")
+        if not project.isDebugPropertiesLoaded():
+            return None, self.__isNetworked, ""
+        
+        # start debugger with project specific settings
+        interpreter = project.getDebugProperty("INTERPRETER")
+        debugClient = project.getDebugProperty("DEBUGCLIENT")
+        
+        redirect = str(project.getDebugProperty("REDIRECT"))
+        noencoding = \
+            project.getDebugProperty("NOENCODING") and '--no-encoding' or ''
+        
+        if project.getDebugProperty("REMOTEDEBUGGER"):
+            ipaddr = self.debugServer.getHostAddress(False)
+            rexec = project.getDebugProperty("REMOTECOMMAND")
+            rhost = project.getDebugProperty("REMOTEHOST")
+            if rhost == "":
+                rhost = "localhost"
+            if rexec:
+                args = Utilities.parseOptionString(rexec) + \
+                    [rhost, interpreter, os.path.abspath(debugClient),
+                        noencoding, str(port), redirect, ipaddr]
+                args[0] = Utilities.getExecutablePath(args[0])
+                process = self.__startProcess(args[0], args[1:])
+                if process is None:
+                    E5MessageBox.critical(
+                        None,
+                        self.tr("Start Debugger"),
+                        self.tr(
+                            """<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.translate = self.__remoteTranslation
+                else:
+                    self.translate = self.__identityTranslation
+                return process, self.__isNetworked, ""
+        
+        # set translation function
+        self.translate = self.__identityTranslation
+        
+        # setup the environment for the debugger
+        if project.getDebugProperty("ENVIRONMENTOVERRIDE"):
+            clientEnv = {}
+        else:
+            clientEnv = os.environ.copy()
+        envlist = Utilities.parseEnvironmentString(
+            project.getDebugProperty("ENVIRONMENTSTRING"))
+        for el in envlist:
+            try:
+                key, value = el.split('=', 1)
+                if value.startswith('"') or value.startswith("'"):
+                    value = value[1:-1]
+                clientEnv[str(key)] = str(value)
+            except ValueError:
+                pass
+        
+        ipaddr = self.debugServer.getHostAddress(True)
+        if runInConsole or project.getDebugProperty("CONSOLEDEBUGGER"):
+            ccmd = project.getDebugProperty("CONSOLECOMMAND") or \
+                Preferences.getDebugger("ConsoleDbgCommand")
+            if ccmd:
+                args = Utilities.parseOptionString(ccmd) + \
+                    [interpreter, os.path.abspath(debugClient),
+                        noencoding, str(port), '0', ipaddr]
+                args[0] = Utilities.getExecutablePath(args[0])
+                process = self.__startProcess(args[0], args[1:], clientEnv)
+                if process is None:
+                    E5MessageBox.critical(
+                        None,
+                        self.tr("Start Debugger"),
+                        self.tr(
+                            """<p>The debugger backend could not be"""
+                            """ started.</p>"""))
+                return process, self.__isNetworked, interpreter
+        
+        process = self.__startProcess(
+            interpreter,
+            [debugClient, noencoding, str(port), redirect, ipaddr],
+            clientEnv)
+        if process is None:
+            E5MessageBox.critical(
+                None,
+                self.tr("Start Debugger"),
+                self.tr(
+                    """<p>The debugger backend could not be started.</p>"""))
+        return process, self.__isNetworked, interpreter
+
+    def getClientCapabilities(self):
+        """
+        Public method to retrieve the debug clients capabilities.
+        
+        @return debug client capabilities (integer)
+        """
+        return self.clientCapabilities
+    
+    def newConnection(self, sock):
+        """
+        Public slot to handle a new connection.
+        
+        @param sock reference to the socket object (QTcpSocket)
+        @return flag indicating success (boolean)
+        """
+        # If we already have a connection, refuse this one.  It will be closed
+        # automatically.
+        if self.qsock is not None:
+            return False
+        
+        sock.disconnected.connect(self.debugServer.startClient)
+        sock.readyRead.connect(self.__parseClientLine)
+        
+        self.qsock = sock
+        
+        # Get the remote clients capabilities
+        self.remoteCapabilities()
+        return True
+    
+    def flush(self):
+        """
+        Public slot to flush the queue.
+        """
+        # Send commands that were waiting for the connection.
+        for cmd in self.queue:
+            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
+        
+        self.queue = []
+    
+    def shutdown(self):
+        """
+        Public method to cleanly shut down.
+        
+        It closes our socket and shuts down
+        the debug client. (Needed on Win OS)
+        """
+        if self.qsock is None:
+            return
+        
+        # do not want any slots called during shutdown
+        self.qsock.disconnected.disconnect(self.debugServer.startClient)
+        self.qsock.readyRead.disconnect(self.__parseClientLine)
+        
+        # close down socket, and shut down client as well.
+        self.__sendJsonCommand("RequestShutdown", {})
+        self.qsock.flush()
+        self.qsock.close()
+        
+        # reinitialize
+        self.qsock = None
+        self.queue = []
+    
+    def isConnected(self):
+        """
+        Public method to test, if a debug client has connected.
+        
+        @return flag indicating the connection status (boolean)
+        """
+        return self.qsock is not None
+    
+    def remoteEnvironment(self, env):
+        """
+        Public method to set the environment for a program to debug, run, ...
+        
+        @param env environment settings (dictionary)
+        """
+        self.__sendJsonCommand("RequestEnvironment", {"environment": env})
+    
+    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)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
+        """
+        self.__autoContinue = autoContinue
+        self.__scriptName = os.path.abspath(fn)
+        
+        wd = self.translate(wd, False)
+        fn = self.translate(os.path.abspath(fn), False)
+        self.__sendJsonCommand("RequestLoad", {
+            "workdir": wd,
+            "filename": fn,
+            "argv": Utilities.parseOptionString(argv),
+            "traceInterpreter": traceInterpreter,
+            "autofork": autoFork,
+            "forkChild": forkChild,
+        })
+    
+    def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
+        """
+        Public method to load a new program to run.
+        
+        @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)
+        @keyparam forkChild flag indicating to debug the child after forking
+            (boolean)
+        """
+        self.__scriptName = os.path.abspath(fn)
+        
+        wd = self.translate(wd, False)
+        fn = self.translate(os.path.abspath(fn), False)
+        self.__sendJsonCommand("RequestRun", {
+            "workdir": wd,
+            "filename": fn,
+            "argv": Utilities.parseOptionString(argv),
+            "autofork": autoFork,
+            "forkChild": forkChild,
+        })
+    
+    def remoteCoverage(self, fn, argv, wd, erase=False):
+        """
+        Public method to load a new program to collect coverage data.
+        
+        @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 coverage info should be
+            cleared first (boolean)
+        """
+        self.__scriptName = os.path.abspath(fn)
+        
+        wd = self.translate(wd, False)
+        fn = self.translate(os.path.abspath(fn), False)
+        self.__sendJsonCommand("RequestCoverage", {
+            "workdir": wd,
+            "filename": fn,
+            "argv": Utilities.parseOptionString(argv),
+            "erase": erase,
+        })
+
+    def remoteProfile(self, fn, argv, wd, erase=False):
+        """
+        Public method to load a new program to collect profiling data.
+        
+        @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)
+        """
+        self.__scriptName = os.path.abspath(fn)
+        
+        wd = self.translate(wd, False)
+        fn = self.translate(os.path.abspath(fn), False)
+        self.__sendJsonCommand("RequestProfile", {
+            "workdir": wd,
+            "filename": fn,
+            "argv": Utilities.parseOptionString(argv),
+            "erase": erase,
+        })
+
+    def remoteStatement(self, stmt):
+        """
+        Public method to execute a Python statement.
+        
+        @param stmt the Python statement to execute (string). It
+              should not have a trailing newline.
+        """
+        self.__sendJsonCommand("ExecuteStatement", {
+            "statement": stmt,
+        })
+
+    def remoteStep(self):
+        """
+        Public method to single step the debugged program.
+        """
+        self.__sendJsonCommand("RequestStep", {})
+
+    def remoteStepOver(self):
+        """
+        Public method to step over the debugged program.
+        """
+        self.__sendJsonCommand("RequestStepOver", {})
+
+    def remoteStepOut(self):
+        """
+        Public method to step out the debugged program.
+        """
+        self.__sendJsonCommand("RequestStepOut", {})
+
+    def remoteStepQuit(self):
+        """
+        Public method to stop the debugged program.
+        """
+        self.__sendJsonCommand("RequestStepQuit", {})
+
+    def remoteContinue(self, special=False):
+        """
+        Public method to continue the debugged program.
+        
+        @param special flag indicating a special continue operation
+        """
+        self.__sendJsonCommand("RequestContinue", {
+            "special": special,
+        })
+
+    def remoteMoveIP(self, line):
+        """
+        Public method to move the instruction pointer to a different line.
+        
+        @param line the new line, where execution should be continued
+        """
+        self.__sendJsonCommand("RequestMoveIP", {
+            "newLine": line,
+        })
+
+    def remoteBreakpoint(self, fn, line, setBreakpoint, cond=None, temp=False):
+        """
+        Public method to set or clear a breakpoint.
+        
+        @param fn filename the breakpoint belongs to (string)
+        @param line linenumber of the breakpoint (int)
+        @param setBreakpoint flag indicating setting or resetting a
+            breakpoint (boolean)
+        @param cond condition of the breakpoint (string)
+        @param temp flag indicating a temporary breakpoint (boolean)
+        """
+        self.__sendJsonCommand("RequestBreakpoint", {
+            "filename": self.translate(fn, False),
+            "line": line,
+            "temporary": temp,
+            "setBreakpoint": setBreakpoint,
+            "condition": cond,
+        })
+    
+    def remoteBreakpointEnable(self, fn, line, enable):
+        """
+        Public method to enable or disable a breakpoint.
+        
+        @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)
+        """
+        self.__sendJsonCommand("RequestBreakpointEnable", {
+            "filename": self.translate(fn, False),
+            "line": line,
+            "enable": enable,
+        })
+    
+    def remoteBreakpointIgnore(self, fn, line, count):
+        """
+        Public method to ignore a breakpoint the next couple of occurrences.
+        
+        @param fn filename the breakpoint belongs to (string)
+        @param line linenumber of the breakpoint (int)
+        @param count number of occurrences to ignore (int)
+        """
+        self.__sendJsonCommand("RequestBreakpointIgnore", {
+            "filename": self.translate(fn, False),
+            "line": line,
+            "count": count,
+        })
+    
+    def remoteWatchpoint(self, cond, setWatch, temp=False):
+        """
+        Public method to set or clear a watch expression.
+        
+        @param cond expression of the watch expression (string)
+        @param setWatch 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)
+        self.__sendJsonCommand("RequestWatch", {
+            "temporary": temp,
+            "setWatch": setWatch,
+            "condition": cond,
+        })
+    
+    def remoteWatchpointEnable(self, cond, enable):
+        """
+        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)
+        """
+        # cond is combination of cond and special (s. watch expression viewer)
+        self.__sendJsonCommand("RequestWatchEnable", {
+            "condition": cond,
+            "enable": enable,
+        })
+    
+    def remoteWatchpointIgnore(self, cond, count):
+        """
+        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)
+        """
+        # cond is combination of cond and special (s. watch expression viewer)
+        self.__sendJsonCommand("RequestWatchIgnore", {
+            "condition": cond,
+            "count": count,
+        })
+    
+    def remoteRawInput(self, s):
+        """
+        Public method to send the raw input to the debugged program.
+        
+        @param s the raw input (string)
+        """
+        self.__sendJsonCommand("RawInput", {
+            "input": s,
+        })
+    
+    def remoteThreadList(self):
+        """
+        Public method to request the list of threads from the client.
+        """
+        self.__sendJsonCommand("RequestThreadList", {})
+        
+    def remoteSetThread(self, tid):
+        """
+        Public method to request to set the given thread as current thread.
+        
+        @param tid id of the thread (integer)
+        """
+        self.__sendJsonCommand("RequestThreadSet", {
+            "threadID": tid,
+        })
+        
+    def remoteClientVariables(self, scope, filterList, framenr=0):
+        """
+        Public method to request the variables of the debugged program.
+        
+        @param scope the scope of the variables (0 = local, 1 = global)
+        @param filterList list of variable types to filter out (list of int)
+        @param framenr framenumber of the variables to retrieve (int)
+        """
+        self.__sendJsonCommand("RequestVariables", {
+            "frameNumber": framenr,
+            "scope": scope,
+            "filters": filterList,
+        })
+    
+    def remoteClientVariable(self, scope, filterList, var, framenr=0):
+        """
+        Public method to request the variables of the debugged program.
+        
+        @param scope the scope of the variables (0 = local, 1 = global)
+        @param filterList list of variable types to filter out (list of int)
+        @param var list encoded name of variable to retrieve (string)
+        @param framenr framenumber of the variables to retrieve (int)
+        """
+        self.__sendJsonCommand("RequestVariable", {
+            "variable": var,
+            "frameNumber": framenr,
+            "scope": scope,
+            "filters": filterList,
+        })
+    
+    def remoteClientSetFilter(self, scope, filterStr):
+        """
+        Public method to set a variables filter list.
+        
+        @param scope the scope of the variables (0 = local, 1 = global)
+        @param filterStr regexp string for variable names to filter out
+            (string)
+        """
+        self.__sendJsonCommand("RequestSetFilter", {
+            "scope": scope,
+            "filter": filterStr,
+        })
+    
+    def setCallTraceEnabled(self, on):
+        """
+        Public method to set the call trace state.
+        
+        @param on flag indicating to enable the call trace function (boolean)
+        """
+        self.__sendJsonCommand("RequestCallTrace", {
+            "enable": on,
+        })
+    
+    def remoteBanner(self):
+        """
+        Public slot to get the banner info of the remote client.
+        """
+        self.__sendJsonCommand("RequestBanner", {})
+    
+    def remoteCapabilities(self):
+        """
+        Public slot to get the debug clients capabilities.
+        """
+        self.__sendJsonCommand("RequestCapabilities", {})
+    
+    def remoteCompletion(self, text):
+        """
+        Public slot to get the a list of possible commandline completions
+        from the remote client.
+        
+        @param text the text to be completed (string)
+        """
+        self.__sendJsonCommand("RequestCompletion", {
+            "text": text,
+        })
+    
+    def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
+        """
+        Public method to prepare a new unittest run.
+        
+        @param fn the filename to load (string)
+        @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)
+        @param covname filename to be used to assemble the coverage caches
+            filename (string)
+        @param coverase flag indicating erasure of coverage data is requested
+            (boolean)
+        """
+        self.__scriptName = os.path.abspath(fn)
+        
+        fn = self.translate(os.path.abspath(fn), False)
+        self.__sendJsonCommand("RequestUTPrepare", {
+            "filename": fn,
+            "testname": tn,
+            "testfunctionname": tfn,
+            "failed": failed,
+            "coverage": cov,
+            "coveragefile": covname,
+            "coverageerase": coverase,
+        })
+    
+    def remoteUTRun(self):
+        """
+        Public method to start a unittest run.
+        """
+        self.__sendJsonCommand("RequestUTRun", {})
+    
+    def remoteUTStop(self):
+        """
+        Public method to stop a unittest run.
+        """
+        self.__sendJsonCommand("RequestUTStop", {})
+    
+    def __askForkTo(self):
+        """
+        Private method to ask the user which branch of a fork to follow.
+        """
+        selections = [self.tr("Parent Process"),
+                      self.tr("Child process")]
+        res, ok = QInputDialog.getItem(
+            None,
+            self.tr("Client forking"),
+            self.tr("Select the fork branch to follow."),
+            selections,
+            0, False)
+        if not ok or res == selections[0]:
+            self.__sendJsonCommand("ResponseForkTo", {
+                "target": "parent",
+            })
+        else:
+            self.__sendJsonCommand("ResponseForkTo", {
+                "target": "child",
+            })
+    
+    def __parseClientLine(self):
+        """
+        Private method to handle data from the client.
+        """
+        while self.qsock and self.qsock.canReadLine():
+            qs = self.qsock.readLine()
+            if self.codec is not None:
+                line = self.codec.toUnicode(qs)
+            else:
+                line = bytes(qs).decode()
+            
+##            print("Server: ", line)          ##debug
+            
+            self.__handleJsonCommand(line)
+            continue
+    
+    def __handleJsonCommand(self, jsonStr):
+        """
+        Private method to handle a command or response serialized as a
+        JSON string.
+        
+        @param jsonStr string containing the command or response received
+            from the debug backend
+        @type str
+        """
+        import json
+        
+        try:
+            commandDict = json.loads(jsonStr.strip())
+        except (TypeError, ValueError) as err:
+            E5MessageBox.critical(
+                None,
+                self.tr("Debug Protocol Error"),
+                self.tr("""<p>The response received from the debugger"""
+                        """ backend could not be decoded. Please report"""
+                        """ this issue with the received data to the"""
+                        """ eric bugs email address.</p>"""
+                        """<p>Error: {0}</p>"""
+                        """<p>Data:<br/>{0}</p>""").format(
+                    str(err), Utilities.html_encode(jsonStr.strip())),
+                E5MessageBox.StandardButtons(
+                    E5MessageBox.Ok))
+            return
+        
+        method = commandDict["method"]
+        params = commandDict["params"]
+        
+        if method == "ClientOutput":
+            self.debugServer.signalClientOutput(params["text"])
+        
+        elif method in ["ResponseLine", "ResponseStack"]:
+            # Check if obsolet thread was clicked
+            if params["stack"] == []:
+                # Request updated list
+                self.remoteThreadList()
+                return
+            for s in params["stack"]:
+                s[0] = self.translate(s[0], True)
+            cf = params["stack"][0]
+            if self.__autoContinue:
+                self.__autoContinue = False
+                QTimer.singleShot(0, self.remoteContinue)
+            else:
+                self.debugServer.signalClientLine(
+                    cf[0], int(cf[1]),
+                    method == "ResponseStack")
+                self.debugServer.signalClientStack(params["stack"])
+        
+        elif method == "CallTrace":
+            isCall = params["event"].lower() == "c"
+            fromInfo = params["from"]
+            toInfo = params["to"]
+            self.debugServer.signalClientCallTrace(
+                isCall,
+                fromInfo["filename"], str(fromInfo["linenumber"]),
+                fromInfo["codename"],
+                toInfo["filename"], str(toInfo["linenumber"]),
+                toInfo["codename"])
+        
+        elif method == "ResponseVariables":
+            self.debugServer.signalClientVariables(
+                params["scope"], params["variables"])
+        
+        elif method == "ResponseVariable":
+            self.debugServer.signalClientVariable(
+                params["scope"], [params["variable"]] + params["variables"])
+        
+        elif method == "ResponseThreadList":
+            self.debugServer.signalClientThreadList(
+                params["currentID"], params["threadList"])
+        
+        elif method == "ResponseThreadSet":
+            self.debugServer.signalClientThreadSet()
+        
+        elif method == "ResponseCapabilities":
+            self.clientCapabilities = params["capabilities"]
+            self.debugServer.signalClientCapabilities(
+                params["capabilities"], params["clientType"])
+        
+        elif method == "ResponseBanner":
+            self.debugServer.signalClientBanner(
+                params["version"],
+                params["platform"],
+                params["dbgclient"])
+        
+        elif method == "ResponseOK":
+            self.debugServer.signalClientStatement(False)
+        
+        elif method == "ResponseContinue":
+            self.debugServer.signalClientStatement(True)
+        
+        elif method == "RequestRaw":
+            self.debugServer.signalClientRawInput(
+                params["prompt"], params["echo"])
+        
+        elif method == "ResponseBPConditionError":
+            fn = self.translate(params["filename"], True)
+            self.debugServer.signalClientBreakConditionError(
+                fn, params["line"])
+        
+        elif method == "ResponseClearBreakpoint":
+            fn = self.translate(params["filename"], True)
+            self.debugServer.signalClientClearBreak(fn, params["line"])
+        
+        elif method == "ResponseWatchConditionError":
+            self.debugServer.signalClientWatchConditionError(
+                params["condition"])
+        
+        elif method == "ResponseClearWatch":
+            self.debugServer.signalClientClearWatch(params["condition"])
+        
+        elif method == "ResponseException":
+            if params:
+                exctype = params["type"]
+                excmessage = params["message"]
+                stack = params["stack"]
+                if stack:
+                    for stackEntry in stack:
+                        stackEntry[0] = self.translate(stackEntry[0], True)
+                    if stack[0] and stack[0][0] == "<string>":
+                        for stackEntry in stack:
+                            if stackEntry[0] == "<string>":
+                                stackEntry[0] = self.__scriptName
+                            else:
+                                break
+            else:
+                exctype = ''
+                excmessage = ''
+                stack = []
+            
+            self.debugServer.signalClientException(
+                exctype, excmessage, stack)
+        
+        elif method == "ResponseSyntax":
+            self.debugServer.signalClientSyntaxError(
+                params["message"], self.translate(params["filename"], True),
+                params["linenumber"], params["characternumber"])
+        
+        elif method == "ResponseSignal":
+            self.debugServer.signalClientSignal(
+                params["message"], self.translate(params["filename"], True),
+                params["linenumber"], params["function"], params["arguments"])
+        
+        elif method == "ResponseExit":
+            self.__scriptName = ""
+            self.debugServer.signalClientExit(
+                params["status"], params["message"])
+        
+        elif method == "PassiveStartup":
+            self.debugServer.passiveStartUp(
+                self.translate(params["filename"], True), params["exceptions"])
+        
+        elif method == "ResponseCompletion":
+            self.debugServer.signalClientCompletionList(
+                params["completions"], params["text"])
+        
+        elif method == "ResponseUTPrepared":
+            self.debugServer.clientUtPrepared(
+                params["count"], params["exception"], params["message"])
+        
+        elif method == "ResponseUTFinished":
+            self.debugServer.clientUtFinished()
+        
+        elif method == "ResponseUTStartTest":
+            self.debugServer.clientUtStartTest(
+                params["testname"], params["description"])
+        
+        elif method == "ResponseUTStopTest":
+            self.debugServer.clientUtStopTest()
+        
+        elif method == "ResponseUTTestFailed":
+            self.debugServer.clientUtTestFailed(
+                params["testname"], params["traceback"], params["id"])
+        
+        elif method == "ResponseUTTestErrored":
+            self.debugServer.clientUtTestErrored(
+                params["testname"], params["traceback"], params["id"])
+        
+        elif method == "ResponseUTTestSkipped":
+            self.debugServer.clientUtTestSkipped(
+                params["testname"], params["reason"], params["id"])
+        
+        elif method == "ResponseUTTestFailedExpected":
+            self.debugServer.clientUtTestFailedExpected(
+                params["testname"], params["traceback"], params["id"])
+        
+        elif method == "ResponseUTTestSucceededUnexpected":
+            self.debugServer.clientUtTestSucceededUnexpected(
+                params["testname"], params["id"])
+        
+        elif method == "RequestForkTo":
+            self.__askForkTo()
+    
+    def __sendJsonCommand(self, command, params):
+        """
+        Private method to send a single command to the client.
+        
+        @param command command name to be sent
+        @type str
+        @param params dictionary of named parameters for the command
+        @type dict
+        """
+        import json
+        
+        commandDict = {
+            "jsonrpc": "2.0",
+            "method": command,
+            "params": params,
+        }
+        cmd = json.dumps(commandDict) + '\n'
+        if self.qsock is not None:
+            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
+        else:
+            self.queue.append(cmd)
+
+
+def createDebuggerInterfacePython2(debugServer, passive):
+    """
+    Module function to create a debugger interface instance.
+    
+        
+    @param debugServer reference to the debug server
+    @type DebugServer
+    @param passive flag indicating passive connection mode
+    @type bool
+    @return instantiated debugger interface
+    @rtype DebuggerInterfacePython
+    """
+    return DebuggerInterfacePython(debugServer, passive, "Python2")
+    
+
+def createDebuggerInterfacePython3(debugServer, passive):
+    """
+    Module function to create a debugger interface instance.
+    
+        
+    @param debugServer reference to the debug server
+    @type DebugServer
+    @param passive flag indicating passive connection mode
+    @type bool
+    @return instantiated debugger interface
+    @rtype DebuggerInterfacePython
+    """
+    return DebuggerInterfacePython(debugServer, passive, "Python3")
+
+
+def getRegistryData():
+    """
+    Module function to get characterizing data for the supported debugger
+    interfaces.
+    
+    @return list of tuples containing the client type, the client capabilities,
+        the client file type associations and a reference to the creation
+        function
+    @rtype list of tuple of (str, int, list of str, function)
+    """
+    py2Exts = []
+    for ext in Preferences.getDebugger("PythonExtensions").split():
+        if ext.startswith("."):
+            py2Exts.append(ext)
+        else:
+            py2Exts.append(".{0}".format(ext))
+    
+    py3Exts = []
+    for ext in Preferences.getDebugger("Python3Extensions").split():
+        if ext.startswith("."):
+            py3Exts.append(ext)
+        else:
+            py3Exts.append(".{0}".format(ext))
+    
+    registryData = []
+    if py2Exts and Preferences.getDebugger("PythonInterpreter"):
+        registryData.append(
+            ("Python2", ClientDefaultCapabilities, py2Exts,
+             createDebuggerInterfacePython2)
+        )
+    
+    if py3Exts and Preferences.getDebugger("Python3Interpreter"):
+        registryData.append(
+            ("Python3", ClientDefaultCapabilities, py3Exts,
+                createDebuggerInterfacePython3)
+        )
+    
+    return registryData
--- a/Debugger/DebuggerInterfacePython2.py	Sat Aug 26 17:10:43 2017 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1103 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2007 - 2017 Detlev Offenbach <detlev@die-offenbachs.de>
-#
-
-"""
-Module implementing the Python debugger interface for the debug server.
-"""
-
-from __future__ import unicode_literals
-
-import sys
-import os
-
-from PyQt5.QtCore import QObject, QTextCodec, QProcess, QProcessEnvironment, \
-    QTimer
-from PyQt5.QtWidgets import QInputDialog
-
-from E5Gui.E5Application import e5App
-from E5Gui import E5MessageBox
-
-from . import DebugClientCapabilities
-
-import Preferences
-import Utilities
-
-from eric6config import getConfig
-
-
-ClientDefaultCapabilities = DebugClientCapabilities.HasAll
-
-
-# TODO: integrate it with DebuggerInterfacePython3 as DebuggerInterfacePython
-class DebuggerInterfacePython2(QObject):
-    """
-    Class implementing the Python 2 debugger interface for the debug server.
-    """
-    def __init__(self, debugServer, passive):
-        """
-        Constructor
-        
-        @param debugServer reference to the debug server (DebugServer)
-        @param passive flag indicating passive connection mode (boolean)
-        """
-        super(DebuggerInterfacePython2, self).__init__()
-        
-        self.__isNetworked = True
-        self.__autoContinue = False
-        
-        self.debugServer = debugServer
-        self.passive = passive
-        self.process = None
-        
-        self.qsock = None
-        self.queue = []
-        
-        # set default values for capabilities of clients
-        self.clientCapabilities = ClientDefaultCapabilities
-        
-        # set translation function
-        self.translate = self.__identityTranslation
-        
-        self.codec = QTextCodec.codecForName(
-            Preferences.getSystem("StringEncoding"))
-        
-        if passive:
-            # set translation function
-            if Preferences.getDebugger("PathTranslation"):
-                self.translateRemote = \
-                    Preferences.getDebugger("PathTranslationRemote")
-                self.translateLocal = \
-                    Preferences.getDebugger("PathTranslationLocal")
-                self.translate = self.__remoteTranslation
-            else:
-                self.translate = self.__identityTranslation
-        
-        # attribute to remember the name of the executed script
-        self.__scriptName = ""
-
-    def __identityTranslation(self, fn, remote2local=True):
-        """
-        Private method to perform the identity path translation.
-        
-        @param fn filename to be translated (string)
-        @param remote2local flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-        @return translated filename (string)
-        """
-        return fn
-        
-    def __remoteTranslation(self, fn, remote2local=True):
-        """
-        Private method to perform the path translation.
-        
-        @param fn filename to be translated (string)
-        @param remote2local flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-        @return translated filename (string)
-        """
-        if remote2local:
-            return fn.replace(self.translateRemote, self.translateLocal)
-        else:
-            return fn.replace(self.translateLocal, self.translateRemote)
-        
-    def __startProcess(self, program, arguments, environment=None):
-        """
-        Private method to start the debugger client process.
-        
-        @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)
-        @return the process object (QProcess) or None
-        """
-        proc = QProcess()
-        if environment is not None:
-            env = QProcessEnvironment()
-            for key, value in list(environment.items()):
-                env.insert(key, value)
-            proc.setProcessEnvironment(env)
-        args = []
-        for arg in arguments:
-            args.append(arg)
-        proc.start(program, args)
-        if not proc.waitForStarted(10000):
-            proc = None
-        
-        return proc
-        
-    def startRemote(self, port, runInConsole):
-        """
-        Public method to start a remote Python interpreter.
-        
-        @param port portnumber the debug server is listening on (integer)
-        @param runInConsole flag indicating to start the debugger in a
-            console window (boolean)
-        @return client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-        """
-        interpreter = Preferences.getDebugger("PythonInterpreter")
-        if interpreter == "":
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>No Python2 interpreter configured.</p>"""))
-            return None, False, ""
-        
-        debugClientType = Preferences.getDebugger("DebugClientType")
-        if debugClientType == "standard":
-            debugClient = os.path.join(getConfig('ericDir'),
-                                       "DebugClients", "Python",
-                                       "DebugClient.py")
-        else:
-            debugClient = Preferences.getDebugger("DebugClient")
-            if debugClient == "":
-                debugClient = os.path.join(sys.path[0],
-                                           "DebugClients", "Python",
-                                           "DebugClient.py")
-        
-        redirect = str(Preferences.getDebugger("PythonRedirect"))
-        noencoding = Preferences.getDebugger("PythonNoEncoding") and \
-            '--no-encoding' or ''
-        
-        if Preferences.getDebugger("RemoteDbgEnabled"):
-            ipaddr = self.debugServer.getHostAddress(False)
-            rexec = Preferences.getDebugger("RemoteExecution")
-            rhost = Preferences.getDebugger("RemoteHost")
-            if rhost == "":
-                rhost = "localhost"
-            if rexec:
-                args = Utilities.parseOptionString(rexec) + \
-                    [rhost, interpreter, debugClient,
-                        noencoding, str(port), redirect, ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:])
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                
-                # set translation function
-                if Preferences.getDebugger("PathTranslation"):
-                    self.translateRemote = \
-                        Preferences.getDebugger("PathTranslationRemote")
-                    self.translateLocal = \
-                        Preferences.getDebugger("PathTranslationLocal")
-                    self.translate = self.__remoteTranslation
-                else:
-                    self.translate = self.__identityTranslation
-                return process, self.__isNetworked, ""
-        
-        # set translation function
-        self.translate = self.__identityTranslation
-        
-        # setup the environment for the debugger
-        if Preferences.getDebugger("DebugEnvironmentReplace"):
-            clientEnv = {}
-        else:
-            clientEnv = os.environ.copy()
-        envlist = Utilities.parseEnvironmentString(
-            Preferences.getDebugger("DebugEnvironment"))
-        for el in envlist:
-            try:
-                key, value = el.split('=', 1)
-                if value.startswith('"') or value.startswith("'"):
-                    value = value[1:-1]
-                clientEnv[str(key)] = str(value)
-            except ValueError:
-                pass
-        
-        ipaddr = self.debugServer.getHostAddress(True)
-        if runInConsole or Preferences.getDebugger("ConsoleDbgEnabled"):
-            ccmd = Preferences.getDebugger("ConsoleDbgCommand")
-            if ccmd:
-                args = Utilities.parseOptionString(ccmd) + \
-                    [interpreter, os.path.abspath(debugClient),
-                        noencoding, str(port), '0', ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:], clientEnv)
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                return process, self.__isNetworked, interpreter
-        
-        process = self.__startProcess(
-            interpreter,
-            [debugClient, noencoding, str(port), redirect, ipaddr],
-            clientEnv)
-        if process is None:
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>The debugger backend could not be started.</p>"""))
-        return process, self.__isNetworked, interpreter
-
-    def startRemoteForProject(self, port, runInConsole):
-        """
-        Public method to start a remote Python interpreter for a project.
-        
-        @param port portnumber the debug server is listening on (integer)
-        @param runInConsole flag indicating to start the debugger in a
-            console window (boolean)
-        @return client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-        """
-        project = e5App().getObject("Project")
-        if not project.isDebugPropertiesLoaded():
-            return None, self.__isNetworked, ""
-        
-        # start debugger with project specific settings
-        interpreter = project.getDebugProperty("INTERPRETER")
-        debugClient = project.getDebugProperty("DEBUGCLIENT")
-        
-        redirect = str(project.getDebugProperty("REDIRECT"))
-        noencoding = \
-            project.getDebugProperty("NOENCODING") and '--no-encoding' or ''
-        
-        if project.getDebugProperty("REMOTEDEBUGGER"):
-            ipaddr = self.debugServer.getHostAddress(False)
-            rexec = project.getDebugProperty("REMOTECOMMAND")
-            rhost = project.getDebugProperty("REMOTEHOST")
-            if rhost == "":
-                rhost = "localhost"
-            if rexec:
-                args = Utilities.parseOptionString(rexec) + \
-                    [rhost, interpreter, os.path.abspath(debugClient),
-                        noencoding, str(port), redirect, ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:])
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<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.translate = self.__remoteTranslation
-                else:
-                    self.translate = self.__identityTranslation
-                return process, self.__isNetworked, ""
-        
-        # set translation function
-        self.translate = self.__identityTranslation
-        
-        # setup the environment for the debugger
-        if project.getDebugProperty("ENVIRONMENTOVERRIDE"):
-            clientEnv = {}
-        else:
-            clientEnv = os.environ.copy()
-        envlist = Utilities.parseEnvironmentString(
-            project.getDebugProperty("ENVIRONMENTSTRING"))
-        for el in envlist:
-            try:
-                key, value = el.split('=', 1)
-                if value.startswith('"') or value.startswith("'"):
-                    value = value[1:-1]
-                clientEnv[str(key)] = str(value)
-            except ValueError:
-                pass
-        
-        ipaddr = self.debugServer.getHostAddress(True)
-        if runInConsole or project.getDebugProperty("CONSOLEDEBUGGER"):
-            ccmd = project.getDebugProperty("CONSOLECOMMAND") or \
-                Preferences.getDebugger("ConsoleDbgCommand")
-            if ccmd:
-                args = Utilities.parseOptionString(ccmd) + \
-                    [interpreter, os.path.abspath(debugClient),
-                        noencoding, str(port), '0', ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:], clientEnv)
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                return process, self.__isNetworked, interpreter
-        
-        process = self.__startProcess(
-            interpreter,
-            [debugClient, noencoding, str(port), redirect, ipaddr],
-            clientEnv)
-        if process is None:
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>The debugger backend could not be started.</p>"""))
-        return process, self.__isNetworked, interpreter
-
-    def getClientCapabilities(self):
-        """
-        Public method to retrieve the debug clients capabilities.
-        
-        @return debug client capabilities (integer)
-        """
-        return self.clientCapabilities
-        
-    def newConnection(self, sock):
-        """
-        Public slot to handle a new connection.
-        
-        @param sock reference to the socket object (QTcpSocket)
-        @return flag indicating success (boolean)
-        """
-        # If we already have a connection, refuse this one.  It will be closed
-        # automatically.
-        if self.qsock is not None:
-            return False
-        
-        sock.disconnected.connect(self.debugServer.startClient)
-        sock.readyRead.connect(self.__parseClientLine)
-        
-        self.qsock = sock
-        
-        # Get the remote clients capabilities
-        self.remoteCapabilities()
-        return True
-        
-    def flush(self):
-        """
-        Public slot to flush the queue.
-        """
-        # Send commands that were waiting for the connection.
-        for cmd in self.queue:
-            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
-        
-        self.queue = []
-        
-    def shutdown(self):
-        """
-        Public method to cleanly shut down.
-        
-        It closes our socket and shuts down
-        the debug client. (Needed on Win OS)
-        """
-        if self.qsock is None:
-            return
-        
-        # do not want any slots called during shutdown
-        self.qsock.disconnected.disconnect(self.debugServer.startClient)
-        self.qsock.readyRead.disconnect(self.__parseClientLine)
-        
-        # close down socket, and shut down client as well.
-        self.__sendJsonCommand("RequestShutdown", {})
-        self.qsock.flush()
-        self.qsock.close()
-        
-        # reinitialize
-        self.qsock = None
-        self.queue = []
-        
-    def isConnected(self):
-        """
-        Public method to test, if a debug client has connected.
-        
-        @return flag indicating the connection status (boolean)
-        """
-        return self.qsock is not None
-        
-    def remoteEnvironment(self, env):
-        """
-        Public method to set the environment for a program to debug, run, ...
-        
-        @param env environment settings (dictionary)
-        """
-        self.__sendJsonCommand("RequestEnvironment", {"environment": env})
-        
-    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)
-        @keyparam forkChild flag indicating to debug the child after forking
-            (boolean)
-        """
-        self.__autoContinue = autoContinue
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestLoad", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "traceInterpreter": traceInterpreter,
-            "autofork": autoFork,
-            "forkChild": forkChild,
-        })
-        
-    def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
-        """
-        Public method to load a new program to run.
-        
-        @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)
-        @keyparam forkChild flag indicating to debug the child after forking
-            (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestRun", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "autofork": autoFork,
-            "forkChild": forkChild,
-        })
-        
-    def remoteCoverage(self, fn, argv, wd, erase=False):
-        """
-        Public method to load a new program to collect coverage data.
-        
-        @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 coverage info should be
-            cleared first (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestCoverage", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "erase": erase,
-        })
-
-    def remoteProfile(self, fn, argv, wd, erase=False):
-        """
-        Public method to load a new program to collect profiling data.
-        
-        @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)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestProfile", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "erase": erase,
-        })
-
-    def remoteStatement(self, stmt):
-        """
-        Public method to execute a Python statement.
-        
-        @param stmt the Python statement to execute (string). It
-              should not have a trailing newline.
-        """
-        self.__sendJsonCommand("ExecuteStatement", {
-            "statement": stmt,
-        })
-
-    def remoteStep(self):
-        """
-        Public method to single step the debugged program.
-        """
-        self.__sendJsonCommand("RequestStep", {})
-
-    def remoteStepOver(self):
-        """
-        Public method to step over the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepOver", {})
-
-    def remoteStepOut(self):
-        """
-        Public method to step out the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepOut", {})
-
-    def remoteStepQuit(self):
-        """
-        Public method to stop the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepQuit", {})
-
-    def remoteContinue(self, special=False):
-        """
-        Public method to continue the debugged program.
-        
-        @param special flag indicating a special continue operation (boolean)
-        """
-        self.__sendJsonCommand("RequestContinue", {
-            "special": special,
-        })
-
-    def remoteMoveIP(self, line):
-        """
-        Public method to move the instruction pointer to a different line.
-        
-        @param line the new line, where execution should be continued
-        """
-        self.__sendJsonCommand("RequestMoveIP", {
-            "newLine": line,
-        })
-
-    def remoteBreakpoint(self, fn, line, setBreakpoint, cond=None, temp=False):
-        """
-        Public method to set or clear a breakpoint.
-        
-        @param fn filename the breakpoint belongs to (string)
-        @param line linenumber of the breakpoint (int)
-        @param setBreakpoint flag indicating setting or resetting a
-            breakpoint (boolean)
-        @param cond condition of the breakpoint (string)
-        @param temp flag indicating a temporary breakpoint (boolean)
-        """
-        self.__sendJsonCommand("RequestBreakpoint", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "temporary": temp,
-            "setBreakpoint": setBreakpoint,
-            "condition": cond,
-        })
-        
-    def remoteBreakpointEnable(self, fn, line, enable):
-        """
-        Public method to enable or disable a breakpoint.
-        
-        @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)
-        """
-        self.__sendJsonCommand("RequestBreakpointEnable", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "enable": enable,
-        })
-        
-    def remoteBreakpointIgnore(self, fn, line, count):
-        """
-        Public method to ignore a breakpoint the next couple of occurrences.
-        
-        @param fn filename the breakpoint belongs to (string)
-        @param line linenumber of the breakpoint (int)
-        @param count number of occurrences to ignore (int)
-        """
-        self.__sendJsonCommand("RequestBreakpointIgnore", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "count": count,
-        })
-        
-    def remoteWatchpoint(self, cond, setWatch, temp=False):
-        """
-        Public method to set or clear a watch expression.
-        
-        @param cond expression of the watch expression (string)
-        @param setWatch 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)
-        self.__sendJsonCommand("RequestWatch", {
-            "temporary": temp,
-            "setWatch": setWatch,
-            "condition": cond,
-        })
-    
-    def remoteWatchpointEnable(self, cond, enable):
-        """
-        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)
-        """
-        # cond is combination of cond and special (s. watch expression viewer)
-        self.__sendJsonCommand("RequestWatchEnable", {
-            "condition": cond,
-            "enable": enable,
-        })
-    
-    def remoteWatchpointIgnore(self, cond, count):
-        """
-        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)
-        """
-        # cond is combination of cond and special (s. watch expression viewer)
-        self.__sendJsonCommand("RequestWatchIgnore", {
-            "condition": cond,
-            "count": count,
-        })
-    
-    def remoteRawInput(self, s):
-        """
-        Public method to send the raw input to the debugged program.
-        
-        @param s the raw input (string)
-        """
-        self.__sendJsonCommand("RawInput", {
-            "input": s,
-        })
-        
-    def remoteThreadList(self):
-        """
-        Public method to request the list of threads from the client.
-        """
-        self.__sendJsonCommand("RequestThreadList", {})
-        
-    def remoteSetThread(self, tid):
-        """
-        Public method to request to set the given thread as current thread.
-        
-        @param tid id of the thread (integer)
-        """
-        self.__sendJsonCommand("RequestThreadSet", {
-            "threadID": tid,
-        })
-        
-    def remoteClientVariables(self, scope, filterList, framenr=0):
-        """
-        Public method to request the variables of the debugged program.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterList list of variable types to filter out (list of int)
-        @param framenr framenumber of the variables to retrieve (int)
-        """
-        self.__sendJsonCommand("RequestVariables", {
-            "frameNumber": framenr,
-            "scope": scope,
-            "filters": filterList,
-        })
-        
-    def remoteClientVariable(self, scope, filterList, var, framenr=0):
-        """
-        Public method to request the variables of the debugged program.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterList list of variable types to filter out (list of int)
-        @param var list encoded name of variable to retrieve (string)
-        @param framenr framenumber of the variables to retrieve (int)
-        """
-        self.__sendJsonCommand("RequestVariable", {
-            "variable": var,
-            "frameNumber": framenr,
-            "scope": scope,
-            "filters": filterList,
-        })
-        
-    def remoteClientSetFilter(self, scope, filterStr):
-        """
-        Public method to set a variables filter list.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterStr regexp string for variable names to filter out
-            (string)
-        """
-        self.__sendJsonCommand("RequestSetFilter", {
-            "scope": scope,
-            "filter": filterStr,
-        })
-        
-    def setCallTraceEnabled(self, on):
-        """
-        Public method to set the call trace state.
-        
-        @param on flag indicating to enable the call trace function (boolean)
-        """
-        self.__sendJsonCommand("RequestCallTrace", {
-            "enable": on,
-        })
-    
-    def remoteBanner(self):
-        """
-        Public slot to get the banner info of the remote client.
-        """
-        self.__sendJsonCommand("RequestBanner", {})
-        
-    def remoteCapabilities(self):
-        """
-        Public slot to get the debug clients capabilities.
-        """
-        self.__sendJsonCommand("RequestCapabilities", {})
-        
-    def remoteCompletion(self, text):
-        """
-        Public slot to get the a list of possible commandline completions
-        from the remote client.
-        
-        @param text the text to be completed (string)
-        """
-        self.__sendJsonCommand("RequestCompletion", {
-            "text": text,
-        })
-        
-    def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
-        """
-        Public method to prepare a new unittest run.
-        
-        @param fn the filename to load (string)
-        @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)
-        @param covname filename to be used to assemble the coverage caches
-            filename (string)
-        @param coverase flag indicating erasure of coverage data is requested
-            (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestUTPrepare", {
-            "filename": fn,
-            "testname": tn,
-            "testfunctionname": tfn,
-            "failed": failed,
-            "coverage": cov,
-            "coveragefile": covname,
-            "coverageerase": coverase,
-        })
-        
-    def remoteUTRun(self):
-        """
-        Public method to start a unittest run.
-        """
-        self.__sendJsonCommand("RequestUTRun", {})
-        
-    def remoteUTStop(self):
-        """
-        Public method to stop a unittest run.
-        """
-        self.__sendJsonCommand("RequestUTStop", {})
-        
-    def __askForkTo(self):
-        """
-        Private method to ask the user which branch of a fork to follow.
-        """
-        selections = [self.tr("Parent Process"),
-                      self.tr("Child process")]
-        res, ok = QInputDialog.getItem(
-            None,
-            self.tr("Client forking"),
-            self.tr("Select the fork branch to follow."),
-            selections,
-            0, False)
-        if not ok or res == selections[0]:
-            self.__sendJsonCommand("ResponseForkTo", {
-                "target": "parent",
-            })
-        else:
-            self.__sendJsonCommand("ResponseForkTo", {
-                "target": "child",
-            })
-        
-    def __parseClientLine(self):
-        """
-        Private method to handle data from the client.
-        """
-        while self.qsock and self.qsock.canReadLine():
-            qs = self.qsock.readLine()
-            if self.codec is not None:
-                line = self.codec.toUnicode(qs)
-            else:
-                line = bytes(qs).decode()
-            
-##            print("Server: ", line)          ##debug
-            
-            self.__handleJsonCommand(line)
-            continue
-    
-    def __handleJsonCommand(self, jsonStr):
-        """
-        Private method to handle a command or response serialized as a
-        JSON string.
-        
-        @param jsonStr string containing the command or response received
-            from the debug backend
-        @type str
-        """
-        import json
-        
-        try:
-            commandDict = json.loads(jsonStr.strip())
-        except (TypeError, ValueError) as err:
-            E5MessageBox.critical(
-                None,
-                self.tr("Debug Protocol Error"),
-                self.tr("""<p>The response received from the debugger"""
-                        """ backend could not be decoded. Please report"""
-                        """ this issue with the received data to the"""
-                        """ eric bugs email address.</p>"""
-                        """<p>Error: {0}</p>"""
-                        """<p>Data:<br/>{0}</p>""").format(
-                    str(err), Utilities.html_encode(jsonStr.strip())),
-                E5MessageBox.StandardButtons(
-                    E5MessageBox.Ok))
-            return
-        
-        method = commandDict["method"]
-        params = commandDict["params"]
-        
-        if method == "ClientOutput":
-            self.debugServer.signalClientOutput(params["text"])
-        
-        elif method in ["ResponseLine", "ResponseStack"]:
-            # Check if obsolet thread was clicked
-            if params["stack"] == []:
-                # Request updated list
-                self.remoteThreadList()
-                return
-            for s in params["stack"]:
-                s[0] = self.translate(s[0], True)
-            cf = params["stack"][0]
-            if self.__autoContinue:
-                self.__autoContinue = False
-                QTimer.singleShot(0, self.remoteContinue)
-            else:
-                self.debugServer.signalClientLine(
-                    cf[0], int(cf[1]),
-                    method == "ResponseStack")
-                self.debugServer.signalClientStack(params["stack"])
-        
-        elif method == "CallTrace":
-            isCall = params["event"].lower() == "c"
-            fromInfo = params["from"]
-            toInfo = params["to"]
-            self.debugServer.signalClientCallTrace(
-                isCall,
-                fromInfo["filename"], str(fromInfo["linenumber"]),
-                fromInfo["codename"],
-                toInfo["filename"], str(toInfo["linenumber"]),
-                toInfo["codename"])
-        
-        elif method == "ResponseVariables":
-            self.debugServer.signalClientVariables(
-                params["scope"], params["variables"])
-        
-        elif method == "ResponseVariable":
-            self.debugServer.signalClientVariable(
-                params["scope"], [params["variable"]] + params["variables"])
-        
-        elif method == "ResponseThreadList":
-            self.debugServer.signalClientThreadList(
-                params["currentID"], params["threadList"])
-        
-        elif method == "ResponseThreadSet":
-            self.debugServer.signalClientThreadSet()
-        
-        elif method == "ResponseCapabilities":
-            self.clientCapabilities = params["capabilities"]
-            self.debugServer.signalClientCapabilities(
-                params["capabilities"], params["clientType"])
-        
-        elif method == "ResponseBanner":
-            self.debugServer.signalClientBanner(
-                params["version"],
-                params["platform"],
-                params["dbgclient"])
-        
-        elif method == "ResponseOK":
-            self.debugServer.signalClientStatement(False)
-        
-        elif method == "ResponseContinue":
-            self.debugServer.signalClientStatement(True)
-        
-        elif method == "RequestRaw":
-            self.debugServer.signalClientRawInput(
-                params["prompt"], params["echo"])
-        
-        elif method == "ResponseBPConditionError":
-            fn = self.translate(params["filename"], True)
-            self.debugServer.signalClientBreakConditionError(
-                fn, params["line"])
-        
-        elif method == "ResponseClearBreakpoint":
-            fn = self.translate(params["filename"], True)
-            self.debugServer.signalClientClearBreak(fn, params["line"])
-        
-        elif method == "ResponseWatchConditionError":
-            self.debugServer.signalClientWatchConditionError(
-                params["condition"])
-        
-        elif method == "ResponseClearWatch":
-            self.debugServer.signalClientClearWatch(params["condition"])
-        
-        elif method == "ResponseException":
-            if params:
-                exctype = params["type"]
-                excmessage = params["message"]
-                stack = params["stack"]
-                if stack:
-                    for stackEntry in stack:
-                        stackEntry[0] = self.translate(stackEntry[0], True)
-                    if stack[0] and stack[0][0] == "<string>":
-                        for stackEntry in stack:
-                            if stackEntry[0] == "<string>":
-                                stackEntry[0] = self.__scriptName
-                            else:
-                                break
-            else:
-                exctype = ''
-                excmessage = ''
-                stack = []
-            
-            self.debugServer.signalClientException(
-                exctype, excmessage, stack)
-        
-        elif method == "ResponseSyntax":
-            self.debugServer.signalClientSyntaxError(
-                params["message"], self.translate(params["filename"], True),
-                params["linenumber"], params["characternumber"])
-        
-        elif method == "ResponseSignal":
-            self.debugServer.signalClientSignal(
-                params["message"], self.translate(params["filename"], True),
-                params["linenumber"], params["function"], params["arguments"])
-        
-        elif method == "ResponseExit":
-            self.__scriptName = ""
-            self.debugServer.signalClientExit(
-                params["status"], params["message"])
-        
-        elif method == "PassiveStartup":
-            self.debugServer.passiveStartUp(
-                self.translate(params["filename"], True), params["exceptions"])
-        
-        elif method == "ResponseCompletion":
-            self.debugServer.signalClientCompletionList(
-                params["completions"], params["text"])
-        
-        elif method == "ResponseUTPrepared":
-            self.debugServer.clientUtPrepared(
-                params["count"], params["exception"], params["message"])
-        
-        elif method == "ResponseUTFinished":
-            self.debugServer.clientUtFinished()
-        
-        elif method == "ResponseUTStartTest":
-            self.debugServer.clientUtStartTest(
-                params["testname"], params["description"])
-        
-        elif method == "ResponseUTStopTest":
-            self.debugServer.clientUtStopTest()
-        
-        elif method == "ResponseUTTestFailed":
-            self.debugServer.clientUtTestFailed(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestErrored":
-            self.debugServer.clientUtTestErrored(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestSkipped":
-            self.debugServer.clientUtTestSkipped(
-                params["testname"], params["reason"], params["id"])
-        
-        elif method == "ResponseUTTestFailedExpected":
-            self.debugServer.clientUtTestFailedExpected(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestSucceededUnexpected":
-            self.debugServer.clientUtTestSucceededUnexpected(
-                params["testname"], params["id"])
-        
-        elif method == "RequestForkTo":
-            self.__askForkTo()
-
-    def __sendJsonCommand(self, command, params):
-        """
-        Private method to send a single command to the client.
-        
-        @param command command name to be sent
-        @type str
-        @param params dictionary of named parameters for the command
-        @type dict
-        """
-        import json
-        
-        commandDict = {
-            "jsonrpc": "2.0",
-            "method": command,
-            "params": params,
-        }
-        cmd = json.dumps(commandDict) + '\n'
-        if self.qsock is not None:
-            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
-        else:
-            self.queue.append(cmd)
-    
-
-def createDebuggerInterfacePython2(debugServer, passive):
-    """
-    Module function to create a debugger interface instance.
-    
-        
-    @param debugServer reference to the debug server
-    @type DebugServer
-    @param passive flag indicating passive connection mode
-    @type bool
-    @return instantiated debugger interface
-    @rtype DebuggerInterfacePython
-    """
-    return DebuggerInterfacePython2(debugServer, passive)
-
-
-def getRegistryData():
-    """
-    Module function to get characterizing data for the debugger interface.
-    
-    @return tuple containing  client type, client capabilities, client file
-        type associations and reference to creation function
-    @rtype tuple of (str, int, list of str, function)
-    """
-    exts = []
-    for ext in Preferences.getDebugger("PythonExtensions").split():
-        if ext.startswith("."):
-            exts.append(ext)
-        else:
-            exts.append(".{0}".format(ext))
-    
-    if exts and Preferences.getDebugger("PythonInterpreter"):
-        return ["Python2", ClientDefaultCapabilities, exts,
-                createDebuggerInterfacePython2]
-    else:
-        return ["", 0, [], None]
--- a/Debugger/DebuggerInterfacePython3.py	Sat Aug 26 17:10:43 2017 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,1107 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2009 - 2017 Detlev Offenbach <detlev@die-offenbachs.de>
-#
-
-"""
-Module implementing the Python3 debugger interface for the debug server.
-"""
-
-from __future__ import unicode_literals
-
-import sys
-import os
-
-from PyQt5.QtCore import QObject, QTextCodec, QProcess, QProcessEnvironment, \
-    QTimer
-from PyQt5.QtWidgets import QInputDialog
-
-from E5Gui.E5Application import e5App
-from E5Gui import E5MessageBox
-
-from . import DebugClientCapabilities
-
-import Preferences
-import Utilities
-
-from eric6config import getConfig
-
-
-ClientDefaultCapabilities = DebugClientCapabilities.HasAll
-
-
-# TODO: integrate DebuggerInterfacePython2 here and rename as DebuggerInterfacePython
-# TODO: introduce a clientType parameter to the constructor being 'Python2' or 'Python3'
-# TODO: determine Preferences parameters based on this clientType
-class DebuggerInterfacePython3(QObject):
-    """
-    Class implementing the Python 3 debugger interface for the debug server.
-    """
-    def __init__(self, debugServer, passive):
-        """
-        Constructor
-        
-        @param debugServer reference to the debug server (DebugServer)
-        @param passive flag indicating passive connection mode (boolean)
-        """
-        super(DebuggerInterfacePython3, self).__init__()
-        
-        self.__isNetworked = True
-        self.__autoContinue = False
-        
-        self.debugServer = debugServer
-        self.passive = passive
-        self.process = None
-        
-        self.qsock = None
-        self.queue = []
-        
-        # set default values for capabilities of clients
-        self.clientCapabilities = ClientDefaultCapabilities
-        
-        # set translation function
-        self.translate = self.__identityTranslation
-        
-        self.codec = QTextCodec.codecForName(
-            str(Preferences.getSystem("StringEncoding")))
-        
-        if passive:
-            # set translation function
-            if Preferences.getDebugger("PathTranslation"):
-                self.translateRemote = \
-                    Preferences.getDebugger("PathTranslationRemote")
-                self.translateLocal = \
-                    Preferences.getDebugger("PathTranslationLocal")
-                self.translate = self.__remoteTranslation
-            else:
-                self.translate = self.__identityTranslation
-        
-        # attribute to remember the name of the executed script
-        self.__scriptName = ""
-
-    def __identityTranslation(self, fn, remote2local=True):
-        """
-        Private method to perform the identity path translation.
-        
-        @param fn filename to be translated (string)
-        @param remote2local flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-        @return translated filename (string)
-        """
-        return fn
-        
-    def __remoteTranslation(self, fn, remote2local=True):
-        """
-        Private method to perform the path translation.
-        
-        @param fn filename to be translated (string)
-        @param remote2local flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-        @return translated filename (string)
-        """
-        if remote2local:
-            return fn.replace(self.translateRemote, self.translateLocal)
-        else:
-            return fn.replace(self.translateLocal, self.translateRemote)
-        
-    def __startProcess(self, program, arguments, environment=None):
-        """
-        Private method to start the debugger client process.
-        
-        @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)
-        @return the process object (QProcess) or None
-        """
-        proc = QProcess()
-        if environment is not None:
-            env = QProcessEnvironment()
-            for key, value in list(environment.items()):
-                env.insert(key, value)
-            proc.setProcessEnvironment(env)
-        args = []
-        for arg in arguments:
-            args.append(arg)
-        proc.start(program, args)
-        if not proc.waitForStarted(10000):
-            proc = None
-        
-        return proc
-        
-    def startRemote(self, port, runInConsole):
-        """
-        Public method to start a remote Python interpreter.
-        
-        @param port portnumber the debug server is listening on (integer)
-        @param runInConsole flag indicating to start the debugger in a
-            console window (boolean)
-        @return client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-        """
-        interpreter = Preferences.getDebugger("Python3Interpreter")
-        if interpreter == "":
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>No Python3 interpreter configured.</p>"""))
-            return None, False, ""
-        
-        debugClientType = Preferences.getDebugger("DebugClientType3")
-        if debugClientType == "standard":
-            debugClient = os.path.join(getConfig('ericDir'),
-                                       "DebugClients", "Python",
-                                       "DebugClient.py")
-        else:
-            debugClient = Preferences.getDebugger("DebugClient3")
-            if debugClient == "":
-                debugClient = os.path.join(sys.path[0],
-                                           "DebugClients", "Python",
-                                           "DebugClient.py")
-        
-        redirect = str(Preferences.getDebugger("Python3Redirect"))
-        noencoding = Preferences.getDebugger("Python3NoEncoding") and \
-            '--no-encoding' or ''
-        
-        if Preferences.getDebugger("RemoteDbgEnabled"):
-            ipaddr = self.debugServer.getHostAddress(False)
-            rexec = Preferences.getDebugger("RemoteExecution")
-            rhost = Preferences.getDebugger("RemoteHost")
-            if rhost == "":
-                rhost = "localhost"
-            if rexec:
-                args = Utilities.parseOptionString(rexec) + \
-                    [rhost, interpreter, debugClient,
-                        noencoding, str(port), redirect, ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:])
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                
-                # set translation function
-                if Preferences.getDebugger("PathTranslation"):
-                    self.translateRemote = \
-                        Preferences.getDebugger("PathTranslationRemote")
-                    self.translateLocal = \
-                        Preferences.getDebugger("PathTranslationLocal")
-                    self.translate = self.__remoteTranslation
-                else:
-                    self.translate = self.__identityTranslation
-                return process, self.__isNetworked, ""
-        
-        # set translation function
-        self.translate = self.__identityTranslation
-        
-        # setup the environment for the debugger
-        if Preferences.getDebugger("DebugEnvironmentReplace"):
-            clientEnv = {}
-        else:
-            clientEnv = os.environ.copy()
-        envlist = Utilities.parseEnvironmentString(
-            Preferences.getDebugger("DebugEnvironment"))
-        for el in envlist:
-            try:
-                key, value = el.split('=', 1)
-                if value.startswith('"') or value.startswith("'"):
-                    value = value[1:-1]
-                clientEnv[str(key)] = str(value)
-            except ValueError:
-                pass
-        
-        ipaddr = self.debugServer.getHostAddress(True)
-        if runInConsole or Preferences.getDebugger("ConsoleDbgEnabled"):
-            ccmd = Preferences.getDebugger("ConsoleDbgCommand")
-            if ccmd:
-                args = Utilities.parseOptionString(ccmd) + \
-                    [interpreter, os.path.abspath(debugClient),
-                        noencoding, str(port), '0', ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:], clientEnv)
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                return process, self.__isNetworked, interpreter
-        
-        process = self.__startProcess(
-            interpreter,
-            [debugClient, noencoding, str(port), redirect, ipaddr],
-            clientEnv)
-        if process is None:
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>The debugger backend could not be started.</p>"""))
-        return process, self.__isNetworked, interpreter
-
-    def startRemoteForProject(self, port, runInConsole):
-        """
-        Public method to start a remote Python interpreter for a project.
-        
-        @param port portnumber the debug server is listening on (integer)
-        @param runInConsole flag indicating to start the debugger in a
-            console window (boolean)
-        @return client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-        """
-        project = e5App().getObject("Project")
-        if not project.isDebugPropertiesLoaded():
-            return None, self.__isNetworked, ""
-        
-        # start debugger with project specific settings
-        interpreter = project.getDebugProperty("INTERPRETER")
-        debugClient = project.getDebugProperty("DEBUGCLIENT")
-        
-        redirect = str(project.getDebugProperty("REDIRECT"))
-        noencoding = \
-            project.getDebugProperty("NOENCODING") and '--no-encoding' or ''
-        
-        if project.getDebugProperty("REMOTEDEBUGGER"):
-            ipaddr = self.debugServer.getHostAddress(False)
-            rexec = project.getDebugProperty("REMOTECOMMAND")
-            rhost = project.getDebugProperty("REMOTEHOST")
-            if rhost == "":
-                rhost = "localhost"
-            if rexec:
-                args = Utilities.parseOptionString(rexec) + \
-                    [rhost, interpreter, os.path.abspath(debugClient),
-                        noencoding, str(port), redirect, ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:])
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<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.translate = self.__remoteTranslation
-                else:
-                    self.translate = self.__identityTranslation
-                return process, self.__isNetworked, ""
-        
-        # set translation function
-        self.translate = self.__identityTranslation
-        
-        # setup the environment for the debugger
-        if project.getDebugProperty("ENVIRONMENTOVERRIDE"):
-            clientEnv = {}
-        else:
-            clientEnv = os.environ.copy()
-        envlist = Utilities.parseEnvironmentString(
-            project.getDebugProperty("ENVIRONMENTSTRING"))
-        for el in envlist:
-            try:
-                key, value = el.split('=', 1)
-                if value.startswith('"') or value.startswith("'"):
-                    value = value[1:-1]
-                clientEnv[str(key)] = str(value)
-            except ValueError:
-                pass
-        
-        ipaddr = self.debugServer.getHostAddress(True)
-        if runInConsole or project.getDebugProperty("CONSOLEDEBUGGER"):
-            ccmd = project.getDebugProperty("CONSOLECOMMAND") or \
-                Preferences.getDebugger("ConsoleDbgCommand")
-            if ccmd:
-                args = Utilities.parseOptionString(ccmd) + \
-                    [interpreter, os.path.abspath(debugClient),
-                        noencoding, str(port), '0', ipaddr]
-                args[0] = Utilities.getExecutablePath(args[0])
-                process = self.__startProcess(args[0], args[1:], clientEnv)
-                if process is None:
-                    E5MessageBox.critical(
-                        None,
-                        self.tr("Start Debugger"),
-                        self.tr(
-                            """<p>The debugger backend could not be"""
-                            """ started.</p>"""))
-                return process, self.__isNetworked, interpreter
-        
-        process = self.__startProcess(
-            interpreter,
-            [debugClient, noencoding, str(port), redirect, ipaddr],
-            clientEnv)
-        if process is None:
-            E5MessageBox.critical(
-                None,
-                self.tr("Start Debugger"),
-                self.tr(
-                    """<p>The debugger backend could not be started.</p>"""))
-        return process, self.__isNetworked, interpreter
-
-    def getClientCapabilities(self):
-        """
-        Public method to retrieve the debug clients capabilities.
-        
-        @return debug client capabilities (integer)
-        """
-        return self.clientCapabilities
-    
-    def newConnection(self, sock):
-        """
-        Public slot to handle a new connection.
-        
-        @param sock reference to the socket object (QTcpSocket)
-        @return flag indicating success (boolean)
-        """
-        # If we already have a connection, refuse this one.  It will be closed
-        # automatically.
-        if self.qsock is not None:
-            return False
-        
-        sock.disconnected.connect(self.debugServer.startClient)
-        sock.readyRead.connect(self.__parseClientLine)
-        
-        self.qsock = sock
-        
-        # Get the remote clients capabilities
-        self.remoteCapabilities()
-        return True
-    
-    def flush(self):
-        """
-        Public slot to flush the queue.
-        """
-        # Send commands that were waiting for the connection.
-        for cmd in self.queue:
-            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
-        
-        self.queue = []
-    
-    def shutdown(self):
-        """
-        Public method to cleanly shut down.
-        
-        It closes our socket and shuts down
-        the debug client. (Needed on Win OS)
-        """
-        if self.qsock is None:
-            return
-        
-        # do not want any slots called during shutdown
-        self.qsock.disconnected.disconnect(self.debugServer.startClient)
-        self.qsock.readyRead.disconnect(self.__parseClientLine)
-        
-        # close down socket, and shut down client as well.
-        self.__sendJsonCommand("RequestShutdown", {})
-        self.qsock.flush()
-        self.qsock.close()
-        
-        # reinitialize
-        self.qsock = None
-        self.queue = []
-    
-    def isConnected(self):
-        """
-        Public method to test, if a debug client has connected.
-        
-        @return flag indicating the connection status (boolean)
-        """
-        return self.qsock is not None
-    
-    def remoteEnvironment(self, env):
-        """
-        Public method to set the environment for a program to debug, run, ...
-        
-        @param env environment settings (dictionary)
-        """
-        self.__sendJsonCommand("RequestEnvironment", {"environment": env})
-    
-    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)
-        @keyparam forkChild flag indicating to debug the child after forking
-            (boolean)
-        """
-        self.__autoContinue = autoContinue
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestLoad", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "traceInterpreter": traceInterpreter,
-            "autofork": autoFork,
-            "forkChild": forkChild,
-        })
-    
-    def remoteRun(self, fn, argv, wd, autoFork=False, forkChild=False):
-        """
-        Public method to load a new program to run.
-        
-        @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)
-        @keyparam forkChild flag indicating to debug the child after forking
-            (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestRun", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "autofork": autoFork,
-            "forkChild": forkChild,
-        })
-    
-    def remoteCoverage(self, fn, argv, wd, erase=False):
-        """
-        Public method to load a new program to collect coverage data.
-        
-        @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 coverage info should be
-            cleared first (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestCoverage", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "erase": erase,
-        })
-
-    def remoteProfile(self, fn, argv, wd, erase=False):
-        """
-        Public method to load a new program to collect profiling data.
-        
-        @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)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        wd = self.translate(wd, False)
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestProfile", {
-            "workdir": wd,
-            "filename": fn,
-            "argv": Utilities.parseOptionString(argv),
-            "erase": erase,
-        })
-
-    def remoteStatement(self, stmt):
-        """
-        Public method to execute a Python statement.
-        
-        @param stmt the Python statement to execute (string). It
-              should not have a trailing newline.
-        """
-        self.__sendJsonCommand("ExecuteStatement", {
-            "statement": stmt,
-        })
-
-    def remoteStep(self):
-        """
-        Public method to single step the debugged program.
-        """
-        self.__sendJsonCommand("RequestStep", {})
-
-    def remoteStepOver(self):
-        """
-        Public method to step over the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepOver", {})
-
-    def remoteStepOut(self):
-        """
-        Public method to step out the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepOut", {})
-
-    def remoteStepQuit(self):
-        """
-        Public method to stop the debugged program.
-        """
-        self.__sendJsonCommand("RequestStepQuit", {})
-
-    def remoteContinue(self, special=False):
-        """
-        Public method to continue the debugged program.
-        
-        @param special flag indicating a special continue operation
-        """
-        self.__sendJsonCommand("RequestContinue", {
-            "special": special,
-        })
-
-    def remoteMoveIP(self, line):
-        """
-        Public method to move the instruction pointer to a different line.
-        
-        @param line the new line, where execution should be continued
-        """
-        self.__sendJsonCommand("RequestMoveIP", {
-            "newLine": line,
-        })
-
-    def remoteBreakpoint(self, fn, line, setBreakpoint, cond=None, temp=False):
-        """
-        Public method to set or clear a breakpoint.
-        
-        @param fn filename the breakpoint belongs to (string)
-        @param line linenumber of the breakpoint (int)
-        @param setBreakpoint flag indicating setting or resetting a
-            breakpoint (boolean)
-        @param cond condition of the breakpoint (string)
-        @param temp flag indicating a temporary breakpoint (boolean)
-        """
-        self.__sendJsonCommand("RequestBreakpoint", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "temporary": temp,
-            "setBreakpoint": setBreakpoint,
-            "condition": cond,
-        })
-    
-    def remoteBreakpointEnable(self, fn, line, enable):
-        """
-        Public method to enable or disable a breakpoint.
-        
-        @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)
-        """
-        self.__sendJsonCommand("RequestBreakpointEnable", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "enable": enable,
-        })
-    
-    def remoteBreakpointIgnore(self, fn, line, count):
-        """
-        Public method to ignore a breakpoint the next couple of occurrences.
-        
-        @param fn filename the breakpoint belongs to (string)
-        @param line linenumber of the breakpoint (int)
-        @param count number of occurrences to ignore (int)
-        """
-        self.__sendJsonCommand("RequestBreakpointIgnore", {
-            "filename": self.translate(fn, False),
-            "line": line,
-            "count": count,
-        })
-    
-    def remoteWatchpoint(self, cond, setWatch, temp=False):
-        """
-        Public method to set or clear a watch expression.
-        
-        @param cond expression of the watch expression (string)
-        @param setWatch 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)
-        self.__sendJsonCommand("RequestWatch", {
-            "temporary": temp,
-            "setWatch": setWatch,
-            "condition": cond,
-        })
-    
-    def remoteWatchpointEnable(self, cond, enable):
-        """
-        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)
-        """
-        # cond is combination of cond and special (s. watch expression viewer)
-        self.__sendJsonCommand("RequestWatchEnable", {
-            "condition": cond,
-            "enable": enable,
-        })
-    
-    def remoteWatchpointIgnore(self, cond, count):
-        """
-        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)
-        """
-        # cond is combination of cond and special (s. watch expression viewer)
-        self.__sendJsonCommand("RequestWatchIgnore", {
-            "condition": cond,
-            "count": count,
-        })
-    
-    def remoteRawInput(self, s):
-        """
-        Public method to send the raw input to the debugged program.
-        
-        @param s the raw input (string)
-        """
-        self.__sendJsonCommand("RawInput", {
-            "input": s,
-        })
-    
-    def remoteThreadList(self):
-        """
-        Public method to request the list of threads from the client.
-        """
-        self.__sendJsonCommand("RequestThreadList", {})
-        
-    def remoteSetThread(self, tid):
-        """
-        Public method to request to set the given thread as current thread.
-        
-        @param tid id of the thread (integer)
-        """
-        self.__sendJsonCommand("RequestThreadSet", {
-            "threadID": tid,
-        })
-        
-    def remoteClientVariables(self, scope, filterList, framenr=0):
-        """
-        Public method to request the variables of the debugged program.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterList list of variable types to filter out (list of int)
-        @param framenr framenumber of the variables to retrieve (int)
-        """
-        self.__sendJsonCommand("RequestVariables", {
-            "frameNumber": framenr,
-            "scope": scope,
-            "filters": filterList,
-        })
-    
-    def remoteClientVariable(self, scope, filterList, var, framenr=0):
-        """
-        Public method to request the variables of the debugged program.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterList list of variable types to filter out (list of int)
-        @param var list encoded name of variable to retrieve (string)
-        @param framenr framenumber of the variables to retrieve (int)
-        """
-        self.__sendJsonCommand("RequestVariable", {
-            "variable": var,
-            "frameNumber": framenr,
-            "scope": scope,
-            "filters": filterList,
-        })
-    
-    def remoteClientSetFilter(self, scope, filterStr):
-        """
-        Public method to set a variables filter list.
-        
-        @param scope the scope of the variables (0 = local, 1 = global)
-        @param filterStr regexp string for variable names to filter out
-            (string)
-        """
-        self.__sendJsonCommand("RequestSetFilter", {
-            "scope": scope,
-            "filter": filterStr,
-        })
-    
-    def setCallTraceEnabled(self, on):
-        """
-        Public method to set the call trace state.
-        
-        @param on flag indicating to enable the call trace function (boolean)
-        """
-        self.__sendJsonCommand("RequestCallTrace", {
-            "enable": on,
-        })
-    
-    def remoteBanner(self):
-        """
-        Public slot to get the banner info of the remote client.
-        """
-        self.__sendJsonCommand("RequestBanner", {})
-    
-    def remoteCapabilities(self):
-        """
-        Public slot to get the debug clients capabilities.
-        """
-        self.__sendJsonCommand("RequestCapabilities", {})
-    
-    def remoteCompletion(self, text):
-        """
-        Public slot to get the a list of possible commandline completions
-        from the remote client.
-        
-        @param text the text to be completed (string)
-        """
-        self.__sendJsonCommand("RequestCompletion", {
-            "text": text,
-        })
-    
-    def remoteUTPrepare(self, fn, tn, tfn, failed, cov, covname, coverase):
-        """
-        Public method to prepare a new unittest run.
-        
-        @param fn the filename to load (string)
-        @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)
-        @param covname filename to be used to assemble the coverage caches
-            filename (string)
-        @param coverase flag indicating erasure of coverage data is requested
-            (boolean)
-        """
-        self.__scriptName = os.path.abspath(fn)
-        
-        fn = self.translate(os.path.abspath(fn), False)
-        self.__sendJsonCommand("RequestUTPrepare", {
-            "filename": fn,
-            "testname": tn,
-            "testfunctionname": tfn,
-            "failed": failed,
-            "coverage": cov,
-            "coveragefile": covname,
-            "coverageerase": coverase,
-        })
-    
-    def remoteUTRun(self):
-        """
-        Public method to start a unittest run.
-        """
-        self.__sendJsonCommand("RequestUTRun", {})
-    
-    def remoteUTStop(self):
-        """
-        Public method to stop a unittest run.
-        """
-        self.__sendJsonCommand("RequestUTStop", {})
-    
-    def __askForkTo(self):
-        """
-        Private method to ask the user which branch of a fork to follow.
-        """
-        selections = [self.tr("Parent Process"),
-                      self.tr("Child process")]
-        res, ok = QInputDialog.getItem(
-            None,
-            self.tr("Client forking"),
-            self.tr("Select the fork branch to follow."),
-            selections,
-            0, False)
-        if not ok or res == selections[0]:
-            self.__sendJsonCommand("ResponseForkTo", {
-                "target": "parent",
-            })
-        else:
-            self.__sendJsonCommand("ResponseForkTo", {
-                "target": "child",
-            })
-    
-    def __parseClientLine(self):
-        """
-        Private method to handle data from the client.
-        """
-        while self.qsock and self.qsock.canReadLine():
-            qs = self.qsock.readLine()
-            if self.codec is not None:
-                line = self.codec.toUnicode(qs)
-            else:
-                line = bytes(qs).decode()
-            
-##            print("Server: ", line)          ##debug
-            
-            self.__handleJsonCommand(line)
-            continue
-    
-    def __handleJsonCommand(self, jsonStr):
-        """
-        Private method to handle a command or response serialized as a
-        JSON string.
-        
-        @param jsonStr string containing the command or response received
-            from the debug backend
-        @type str
-        """
-        import json
-        
-        try:
-            commandDict = json.loads(jsonStr.strip())
-        except (TypeError, ValueError) as err:
-            E5MessageBox.critical(
-                None,
-                self.tr("Debug Protocol Error"),
-                self.tr("""<p>The response received from the debugger"""
-                        """ backend could not be decoded. Please report"""
-                        """ this issue with the received data to the"""
-                        """ eric bugs email address.</p>"""
-                        """<p>Error: {0}</p>"""
-                        """<p>Data:<br/>{0}</p>""").format(
-                    str(err), Utilities.html_encode(jsonStr.strip())),
-                E5MessageBox.StandardButtons(
-                    E5MessageBox.Ok))
-            return
-        
-        method = commandDict["method"]
-        params = commandDict["params"]
-        
-        if method == "ClientOutput":
-            self.debugServer.signalClientOutput(params["text"])
-        
-        elif method in ["ResponseLine", "ResponseStack"]:
-            # Check if obsolet thread was clicked
-            if params["stack"] == []:
-                # Request updated list
-                self.remoteThreadList()
-                return
-            for s in params["stack"]:
-                s[0] = self.translate(s[0], True)
-            cf = params["stack"][0]
-            if self.__autoContinue:
-                self.__autoContinue = False
-                QTimer.singleShot(0, self.remoteContinue)
-            else:
-                self.debugServer.signalClientLine(
-                    cf[0], int(cf[1]),
-                    method == "ResponseStack")
-                self.debugServer.signalClientStack(params["stack"])
-        
-        elif method == "CallTrace":
-            isCall = params["event"].lower() == "c"
-            fromInfo = params["from"]
-            toInfo = params["to"]
-            self.debugServer.signalClientCallTrace(
-                isCall,
-                fromInfo["filename"], str(fromInfo["linenumber"]),
-                fromInfo["codename"],
-                toInfo["filename"], str(toInfo["linenumber"]),
-                toInfo["codename"])
-        
-        elif method == "ResponseVariables":
-            self.debugServer.signalClientVariables(
-                params["scope"], params["variables"])
-        
-        elif method == "ResponseVariable":
-            self.debugServer.signalClientVariable(
-                params["scope"], [params["variable"]] + params["variables"])
-        
-        elif method == "ResponseThreadList":
-            self.debugServer.signalClientThreadList(
-                params["currentID"], params["threadList"])
-        
-        elif method == "ResponseThreadSet":
-            self.debugServer.signalClientThreadSet()
-        
-        elif method == "ResponseCapabilities":
-            self.clientCapabilities = params["capabilities"]
-            self.debugServer.signalClientCapabilities(
-                params["capabilities"], params["clientType"])
-        
-        elif method == "ResponseBanner":
-            self.debugServer.signalClientBanner(
-                params["version"],
-                params["platform"],
-                params["dbgclient"])
-        
-        elif method == "ResponseOK":
-            self.debugServer.signalClientStatement(False)
-        
-        elif method == "ResponseContinue":
-            self.debugServer.signalClientStatement(True)
-        
-        elif method == "RequestRaw":
-            self.debugServer.signalClientRawInput(
-                params["prompt"], params["echo"])
-        
-        elif method == "ResponseBPConditionError":
-            fn = self.translate(params["filename"], True)
-            self.debugServer.signalClientBreakConditionError(
-                fn, params["line"])
-        
-        elif method == "ResponseClearBreakpoint":
-            fn = self.translate(params["filename"], True)
-            self.debugServer.signalClientClearBreak(fn, params["line"])
-        
-        elif method == "ResponseWatchConditionError":
-            self.debugServer.signalClientWatchConditionError(
-                params["condition"])
-        
-        elif method == "ResponseClearWatch":
-            self.debugServer.signalClientClearWatch(params["condition"])
-        
-        elif method == "ResponseException":
-            if params:
-                exctype = params["type"]
-                excmessage = params["message"]
-                stack = params["stack"]
-                if stack:
-                    for stackEntry in stack:
-                        stackEntry[0] = self.translate(stackEntry[0], True)
-                    if stack[0] and stack[0][0] == "<string>":
-                        for stackEntry in stack:
-                            if stackEntry[0] == "<string>":
-                                stackEntry[0] = self.__scriptName
-                            else:
-                                break
-            else:
-                exctype = ''
-                excmessage = ''
-                stack = []
-            
-            self.debugServer.signalClientException(
-                exctype, excmessage, stack)
-        
-        elif method == "ResponseSyntax":
-            self.debugServer.signalClientSyntaxError(
-                params["message"], self.translate(params["filename"], True),
-                params["linenumber"], params["characternumber"])
-        
-        elif method == "ResponseSignal":
-            self.debugServer.signalClientSignal(
-                params["message"], self.translate(params["filename"], True),
-                params["linenumber"], params["function"], params["arguments"])
-        
-        elif method == "ResponseExit":
-            self.__scriptName = ""
-            self.debugServer.signalClientExit(
-                params["status"], params["message"])
-        
-        elif method == "PassiveStartup":
-            self.debugServer.passiveStartUp(
-                self.translate(params["filename"], True), params["exceptions"])
-        
-        elif method == "ResponseCompletion":
-            self.debugServer.signalClientCompletionList(
-                params["completions"], params["text"])
-        
-        elif method == "ResponseUTPrepared":
-            self.debugServer.clientUtPrepared(
-                params["count"], params["exception"], params["message"])
-        
-        elif method == "ResponseUTFinished":
-            self.debugServer.clientUtFinished()
-        
-        elif method == "ResponseUTStartTest":
-            self.debugServer.clientUtStartTest(
-                params["testname"], params["description"])
-        
-        elif method == "ResponseUTStopTest":
-            self.debugServer.clientUtStopTest()
-        
-        elif method == "ResponseUTTestFailed":
-            self.debugServer.clientUtTestFailed(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestErrored":
-            self.debugServer.clientUtTestErrored(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestSkipped":
-            self.debugServer.clientUtTestSkipped(
-                params["testname"], params["reason"], params["id"])
-        
-        elif method == "ResponseUTTestFailedExpected":
-            self.debugServer.clientUtTestFailedExpected(
-                params["testname"], params["traceback"], params["id"])
-        
-        elif method == "ResponseUTTestSucceededUnexpected":
-            self.debugServer.clientUtTestSucceededUnexpected(
-                params["testname"], params["id"])
-        
-        elif method == "RequestForkTo":
-            self.__askForkTo()
-    
-    def __sendJsonCommand(self, command, params):
-        """
-        Private method to send a single command to the client.
-        
-        @param command command name to be sent
-        @type str
-        @param params dictionary of named parameters for the command
-        @type dict
-        """
-        import json
-        
-        commandDict = {
-            "jsonrpc": "2.0",
-            "method": command,
-            "params": params,
-        }
-        cmd = json.dumps(commandDict) + '\n'
-        if self.qsock is not None:
-            self.qsock.write(cmd.encode('utf8', 'backslashreplace'))
-        else:
-            self.queue.append(cmd)
-    
-
-# TODO: duplicate to create the interface object for Python2
-def createDebuggerInterfacePython3(debugServer, passive):
-    """
-    Module function to create a debugger interface instance.
-    
-        
-    @param debugServer reference to the debug server
-    @type DebugServer
-    @param passive flag indicating passive connection mode
-    @type bool
-    @return instantiated debugger interface
-    @rtype DebuggerInterfacePython
-    """
-    return DebuggerInterfacePython3(debugServer, passive)
-
-
-# TODO: change this to return a list of registry data tuples (one for Python2 and one for Python3)
-def getRegistryData():
-    """
-    Module function to get characterizing data for the debugger interface.
-    
-    @return tuple containing  client type, client capabilities, client file
-        type associations and reference to creation function
-    @rtype tuple of (str, int, list of str, function)
-    """
-    exts = []
-    for ext in Preferences.getDebugger("Python3Extensions").split():
-        if ext.startswith("."):
-            exts.append(ext)
-        else:
-            exts.append(".{0}".format(ext))
-    
-    if exts and Preferences.getDebugger("Python3Interpreter"):
-        return ["Python3", ClientDefaultCapabilities, exts,
-                createDebuggerInterfacePython3]
-    else:
-        return ["", 0, [], None]
Binary file Documentation/Help/source.qch has changed
--- a/Documentation/Help/source.qhp	Sat Aug 26 17:10:43 2017 +0200
+++ b/Documentation/Help/source.qhp	Sat Aug 26 19:26:07 2017 +0200
@@ -54,8 +54,8 @@
             <section title="eric6.Debugger.DebugUI" ref="eric6.Debugger.DebugUI.html" />
             <section title="eric6.Debugger.DebugViewer" ref="eric6.Debugger.DebugViewer.html" />
             <section title="eric6.Debugger.DebuggerInterfaceNone" ref="eric6.Debugger.DebuggerInterfaceNone.html" />
+            <section title="eric6.Debugger.DebuggerInterfacePython" ref="eric6.Debugger.DebuggerInterfacePython.html" />
             <section title="eric6.Debugger.DebuggerInterfacePython2" ref="eric6.Debugger.DebuggerInterfacePython2.html" />
-            <section title="eric6.Debugger.DebuggerInterfacePython3" ref="eric6.Debugger.DebuggerInterfacePython3.html" />
             <section title="eric6.Debugger.EditBreakpointDialog" ref="eric6.Debugger.EditBreakpointDialog.html" />
             <section title="eric6.Debugger.EditWatchpointDialog" ref="eric6.Debugger.EditWatchpointDialog.html" />
             <section title="eric6.Debugger.ExceptionLogger" ref="eric6.Debugger.ExceptionLogger.html" />
@@ -3684,102 +3684,55 @@
       <keyword name="DebuggerInterfaceNone.shutdown" id="DebuggerInterfaceNone.shutdown" ref="eric6.Debugger.DebuggerInterfaceNone.html#DebuggerInterfaceNone.shutdown" />
       <keyword name="DebuggerInterfaceNone.startRemote" id="DebuggerInterfaceNone.startRemote" ref="eric6.Debugger.DebuggerInterfaceNone.html#DebuggerInterfaceNone.startRemote" />
       <keyword name="DebuggerInterfaceNone.startRemoteForProject" id="DebuggerInterfaceNone.startRemoteForProject" ref="eric6.Debugger.DebuggerInterfaceNone.html#DebuggerInterfaceNone.startRemoteForProject" />
-      <keyword name="DebuggerInterfacePython2" id="DebuggerInterfacePython2" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2" />
-      <keyword name="DebuggerInterfacePython2 (Constructor)" id="DebuggerInterfacePython2 (Constructor)" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.__init__" />
+      <keyword name="DebuggerInterfacePython" id="DebuggerInterfacePython" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython" />
+      <keyword name="DebuggerInterfacePython (Constructor)" id="DebuggerInterfacePython (Constructor)" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.__init__" />
+      <keyword name="DebuggerInterfacePython (Module)" id="DebuggerInterfacePython (Module)" ref="eric6.Debugger.DebuggerInterfacePython.html" />
+      <keyword name="DebuggerInterfacePython.__askForkTo" id="DebuggerInterfacePython.__askForkTo" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.__askForkTo" />
+      <keyword name="DebuggerInterfacePython.__handleJsonCommand" id="DebuggerInterfacePython.__handleJsonCommand" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.__handleJsonCommand" />
+      <keyword name="DebuggerInterfacePython.__identityTranslation" id="DebuggerInterfacePython.__identityTranslation" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.__identityTranslation" />
+      <keyword name="DebuggerInterfacePython.__parseClientLine" id="DebuggerInterfacePython.__parseClientLine" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.__parseClientLine" />
+      <keyword name="DebuggerInterfacePython.__remoteTranslation" id="DebuggerInterfacePython.__remoteTranslation" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.__remoteTranslation" />
+      <keyword name="DebuggerInterfacePython.__sendJsonCommand" id="DebuggerInterfacePython.__sendJsonCommand" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.__sendJsonCommand" />
+      <keyword name="DebuggerInterfacePython.__startProcess" id="DebuggerInterfacePython.__startProcess" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.__startProcess" />
+      <keyword name="DebuggerInterfacePython.flush" id="DebuggerInterfacePython.flush" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.flush" />
+      <keyword name="DebuggerInterfacePython.getClientCapabilities" id="DebuggerInterfacePython.getClientCapabilities" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.getClientCapabilities" />
+      <keyword name="DebuggerInterfacePython.isConnected" id="DebuggerInterfacePython.isConnected" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.isConnected" />
+      <keyword name="DebuggerInterfacePython.newConnection" id="DebuggerInterfacePython.newConnection" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.newConnection" />
+      <keyword name="DebuggerInterfacePython.remoteBanner" id="DebuggerInterfacePython.remoteBanner" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteBanner" />
+      <keyword name="DebuggerInterfacePython.remoteBreakpoint" id="DebuggerInterfacePython.remoteBreakpoint" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteBreakpoint" />
+      <keyword name="DebuggerInterfacePython.remoteBreakpointEnable" id="DebuggerInterfacePython.remoteBreakpointEnable" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteBreakpointEnable" />
+      <keyword name="DebuggerInterfacePython.remoteBreakpointIgnore" id="DebuggerInterfacePython.remoteBreakpointIgnore" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteBreakpointIgnore" />
+      <keyword name="DebuggerInterfacePython.remoteCapabilities" id="DebuggerInterfacePython.remoteCapabilities" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteCapabilities" />
+      <keyword name="DebuggerInterfacePython.remoteClientSetFilter" id="DebuggerInterfacePython.remoteClientSetFilter" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteClientSetFilter" />
+      <keyword name="DebuggerInterfacePython.remoteClientVariable" id="DebuggerInterfacePython.remoteClientVariable" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteClientVariable" />
+      <keyword name="DebuggerInterfacePython.remoteClientVariables" id="DebuggerInterfacePython.remoteClientVariables" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteClientVariables" />
+      <keyword name="DebuggerInterfacePython.remoteCompletion" id="DebuggerInterfacePython.remoteCompletion" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteCompletion" />
+      <keyword name="DebuggerInterfacePython.remoteContinue" id="DebuggerInterfacePython.remoteContinue" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteContinue" />
+      <keyword name="DebuggerInterfacePython.remoteCoverage" id="DebuggerInterfacePython.remoteCoverage" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteCoverage" />
+      <keyword name="DebuggerInterfacePython.remoteEnvironment" id="DebuggerInterfacePython.remoteEnvironment" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteEnvironment" />
+      <keyword name="DebuggerInterfacePython.remoteLoad" id="DebuggerInterfacePython.remoteLoad" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteLoad" />
+      <keyword name="DebuggerInterfacePython.remoteMoveIP" id="DebuggerInterfacePython.remoteMoveIP" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteMoveIP" />
+      <keyword name="DebuggerInterfacePython.remoteProfile" id="DebuggerInterfacePython.remoteProfile" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteProfile" />
+      <keyword name="DebuggerInterfacePython.remoteRawInput" id="DebuggerInterfacePython.remoteRawInput" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteRawInput" />
+      <keyword name="DebuggerInterfacePython.remoteRun" id="DebuggerInterfacePython.remoteRun" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteRun" />
+      <keyword name="DebuggerInterfacePython.remoteSetThread" id="DebuggerInterfacePython.remoteSetThread" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteSetThread" />
+      <keyword name="DebuggerInterfacePython.remoteStatement" id="DebuggerInterfacePython.remoteStatement" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteStatement" />
+      <keyword name="DebuggerInterfacePython.remoteStep" id="DebuggerInterfacePython.remoteStep" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteStep" />
+      <keyword name="DebuggerInterfacePython.remoteStepOut" id="DebuggerInterfacePython.remoteStepOut" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteStepOut" />
+      <keyword name="DebuggerInterfacePython.remoteStepOver" id="DebuggerInterfacePython.remoteStepOver" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteStepOver" />
+      <keyword name="DebuggerInterfacePython.remoteStepQuit" id="DebuggerInterfacePython.remoteStepQuit" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteStepQuit" />
+      <keyword name="DebuggerInterfacePython.remoteThreadList" id="DebuggerInterfacePython.remoteThreadList" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteThreadList" />
+      <keyword name="DebuggerInterfacePython.remoteUTPrepare" id="DebuggerInterfacePython.remoteUTPrepare" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteUTPrepare" />
+      <keyword name="DebuggerInterfacePython.remoteUTRun" id="DebuggerInterfacePython.remoteUTRun" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteUTRun" />
+      <keyword name="DebuggerInterfacePython.remoteUTStop" id="DebuggerInterfacePython.remoteUTStop" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteUTStop" />
+      <keyword name="DebuggerInterfacePython.remoteWatchpoint" id="DebuggerInterfacePython.remoteWatchpoint" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteWatchpoint" />
+      <keyword name="DebuggerInterfacePython.remoteWatchpointEnable" id="DebuggerInterfacePython.remoteWatchpointEnable" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteWatchpointEnable" />
+      <keyword name="DebuggerInterfacePython.remoteWatchpointIgnore" id="DebuggerInterfacePython.remoteWatchpointIgnore" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.remoteWatchpointIgnore" />
+      <keyword name="DebuggerInterfacePython.setCallTraceEnabled" id="DebuggerInterfacePython.setCallTraceEnabled" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.setCallTraceEnabled" />
+      <keyword name="DebuggerInterfacePython.shutdown" id="DebuggerInterfacePython.shutdown" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.shutdown" />
+      <keyword name="DebuggerInterfacePython.startRemote" id="DebuggerInterfacePython.startRemote" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.startRemote" />
+      <keyword name="DebuggerInterfacePython.startRemoteForProject" id="DebuggerInterfacePython.startRemoteForProject" ref="eric6.Debugger.DebuggerInterfacePython.html#DebuggerInterfacePython.startRemoteForProject" />
       <keyword name="DebuggerInterfacePython2 (Module)" id="DebuggerInterfacePython2 (Module)" ref="eric6.Debugger.DebuggerInterfacePython2.html" />
-      <keyword name="DebuggerInterfacePython2.__askForkTo" id="DebuggerInterfacePython2.__askForkTo" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.__askForkTo" />
-      <keyword name="DebuggerInterfacePython2.__handleJsonCommand" id="DebuggerInterfacePython2.__handleJsonCommand" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.__handleJsonCommand" />
-      <keyword name="DebuggerInterfacePython2.__identityTranslation" id="DebuggerInterfacePython2.__identityTranslation" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.__identityTranslation" />
-      <keyword name="DebuggerInterfacePython2.__parseClientLine" id="DebuggerInterfacePython2.__parseClientLine" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.__parseClientLine" />
-      <keyword name="DebuggerInterfacePython2.__remoteTranslation" id="DebuggerInterfacePython2.__remoteTranslation" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.__remoteTranslation" />
-      <keyword name="DebuggerInterfacePython2.__sendJsonCommand" id="DebuggerInterfacePython2.__sendJsonCommand" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.__sendJsonCommand" />
-      <keyword name="DebuggerInterfacePython2.__startProcess" id="DebuggerInterfacePython2.__startProcess" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.__startProcess" />
-      <keyword name="DebuggerInterfacePython2.flush" id="DebuggerInterfacePython2.flush" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.flush" />
-      <keyword name="DebuggerInterfacePython2.getClientCapabilities" id="DebuggerInterfacePython2.getClientCapabilities" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.getClientCapabilities" />
-      <keyword name="DebuggerInterfacePython2.isConnected" id="DebuggerInterfacePython2.isConnected" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.isConnected" />
-      <keyword name="DebuggerInterfacePython2.newConnection" id="DebuggerInterfacePython2.newConnection" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.newConnection" />
-      <keyword name="DebuggerInterfacePython2.remoteBanner" id="DebuggerInterfacePython2.remoteBanner" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteBanner" />
-      <keyword name="DebuggerInterfacePython2.remoteBreakpoint" id="DebuggerInterfacePython2.remoteBreakpoint" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteBreakpoint" />
-      <keyword name="DebuggerInterfacePython2.remoteBreakpointEnable" id="DebuggerInterfacePython2.remoteBreakpointEnable" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteBreakpointEnable" />
-      <keyword name="DebuggerInterfacePython2.remoteBreakpointIgnore" id="DebuggerInterfacePython2.remoteBreakpointIgnore" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteBreakpointIgnore" />
-      <keyword name="DebuggerInterfacePython2.remoteCapabilities" id="DebuggerInterfacePython2.remoteCapabilities" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteCapabilities" />
-      <keyword name="DebuggerInterfacePython2.remoteClientSetFilter" id="DebuggerInterfacePython2.remoteClientSetFilter" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteClientSetFilter" />
-      <keyword name="DebuggerInterfacePython2.remoteClientVariable" id="DebuggerInterfacePython2.remoteClientVariable" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteClientVariable" />
-      <keyword name="DebuggerInterfacePython2.remoteClientVariables" id="DebuggerInterfacePython2.remoteClientVariables" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteClientVariables" />
-      <keyword name="DebuggerInterfacePython2.remoteCompletion" id="DebuggerInterfacePython2.remoteCompletion" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteCompletion" />
-      <keyword name="DebuggerInterfacePython2.remoteContinue" id="DebuggerInterfacePython2.remoteContinue" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteContinue" />
-      <keyword name="DebuggerInterfacePython2.remoteCoverage" id="DebuggerInterfacePython2.remoteCoverage" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteCoverage" />
-      <keyword name="DebuggerInterfacePython2.remoteEnvironment" id="DebuggerInterfacePython2.remoteEnvironment" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteEnvironment" />
-      <keyword name="DebuggerInterfacePython2.remoteLoad" id="DebuggerInterfacePython2.remoteLoad" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteLoad" />
-      <keyword name="DebuggerInterfacePython2.remoteMoveIP" id="DebuggerInterfacePython2.remoteMoveIP" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteMoveIP" />
-      <keyword name="DebuggerInterfacePython2.remoteProfile" id="DebuggerInterfacePython2.remoteProfile" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteProfile" />
-      <keyword name="DebuggerInterfacePython2.remoteRawInput" id="DebuggerInterfacePython2.remoteRawInput" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteRawInput" />
-      <keyword name="DebuggerInterfacePython2.remoteRun" id="DebuggerInterfacePython2.remoteRun" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteRun" />
-      <keyword name="DebuggerInterfacePython2.remoteSetThread" id="DebuggerInterfacePython2.remoteSetThread" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteSetThread" />
-      <keyword name="DebuggerInterfacePython2.remoteStatement" id="DebuggerInterfacePython2.remoteStatement" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteStatement" />
-      <keyword name="DebuggerInterfacePython2.remoteStep" id="DebuggerInterfacePython2.remoteStep" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteStep" />
-      <keyword name="DebuggerInterfacePython2.remoteStepOut" id="DebuggerInterfacePython2.remoteStepOut" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteStepOut" />
-      <keyword name="DebuggerInterfacePython2.remoteStepOver" id="DebuggerInterfacePython2.remoteStepOver" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteStepOver" />
-      <keyword name="DebuggerInterfacePython2.remoteStepQuit" id="DebuggerInterfacePython2.remoteStepQuit" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteStepQuit" />
-      <keyword name="DebuggerInterfacePython2.remoteThreadList" id="DebuggerInterfacePython2.remoteThreadList" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteThreadList" />
-      <keyword name="DebuggerInterfacePython2.remoteUTPrepare" id="DebuggerInterfacePython2.remoteUTPrepare" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteUTPrepare" />
-      <keyword name="DebuggerInterfacePython2.remoteUTRun" id="DebuggerInterfacePython2.remoteUTRun" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteUTRun" />
-      <keyword name="DebuggerInterfacePython2.remoteUTStop" id="DebuggerInterfacePython2.remoteUTStop" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteUTStop" />
-      <keyword name="DebuggerInterfacePython2.remoteWatchpoint" id="DebuggerInterfacePython2.remoteWatchpoint" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteWatchpoint" />
-      <keyword name="DebuggerInterfacePython2.remoteWatchpointEnable" id="DebuggerInterfacePython2.remoteWatchpointEnable" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteWatchpointEnable" />
-      <keyword name="DebuggerInterfacePython2.remoteWatchpointIgnore" id="DebuggerInterfacePython2.remoteWatchpointIgnore" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.remoteWatchpointIgnore" />
-      <keyword name="DebuggerInterfacePython2.setCallTraceEnabled" id="DebuggerInterfacePython2.setCallTraceEnabled" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.setCallTraceEnabled" />
-      <keyword name="DebuggerInterfacePython2.shutdown" id="DebuggerInterfacePython2.shutdown" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.shutdown" />
-      <keyword name="DebuggerInterfacePython2.startRemote" id="DebuggerInterfacePython2.startRemote" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.startRemote" />
-      <keyword name="DebuggerInterfacePython2.startRemoteForProject" id="DebuggerInterfacePython2.startRemoteForProject" ref="eric6.Debugger.DebuggerInterfacePython2.html#DebuggerInterfacePython2.startRemoteForProject" />
-      <keyword name="DebuggerInterfacePython3" id="DebuggerInterfacePython3" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3" />
-      <keyword name="DebuggerInterfacePython3 (Constructor)" id="DebuggerInterfacePython3 (Constructor)" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.__init__" />
-      <keyword name="DebuggerInterfacePython3 (Module)" id="DebuggerInterfacePython3 (Module)" ref="eric6.Debugger.DebuggerInterfacePython3.html" />
-      <keyword name="DebuggerInterfacePython3.__askForkTo" id="DebuggerInterfacePython3.__askForkTo" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.__askForkTo" />
-      <keyword name="DebuggerInterfacePython3.__handleJsonCommand" id="DebuggerInterfacePython3.__handleJsonCommand" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.__handleJsonCommand" />
-      <keyword name="DebuggerInterfacePython3.__identityTranslation" id="DebuggerInterfacePython3.__identityTranslation" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.__identityTranslation" />
-      <keyword name="DebuggerInterfacePython3.__parseClientLine" id="DebuggerInterfacePython3.__parseClientLine" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.__parseClientLine" />
-      <keyword name="DebuggerInterfacePython3.__remoteTranslation" id="DebuggerInterfacePython3.__remoteTranslation" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.__remoteTranslation" />
-      <keyword name="DebuggerInterfacePython3.__sendJsonCommand" id="DebuggerInterfacePython3.__sendJsonCommand" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.__sendJsonCommand" />
-      <keyword name="DebuggerInterfacePython3.__startProcess" id="DebuggerInterfacePython3.__startProcess" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.__startProcess" />
-      <keyword name="DebuggerInterfacePython3.flush" id="DebuggerInterfacePython3.flush" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.flush" />
-      <keyword name="DebuggerInterfacePython3.getClientCapabilities" id="DebuggerInterfacePython3.getClientCapabilities" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.getClientCapabilities" />
-      <keyword name="DebuggerInterfacePython3.isConnected" id="DebuggerInterfacePython3.isConnected" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.isConnected" />
-      <keyword name="DebuggerInterfacePython3.newConnection" id="DebuggerInterfacePython3.newConnection" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.newConnection" />
-      <keyword name="DebuggerInterfacePython3.remoteBanner" id="DebuggerInterfacePython3.remoteBanner" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteBanner" />
-      <keyword name="DebuggerInterfacePython3.remoteBreakpoint" id="DebuggerInterfacePython3.remoteBreakpoint" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteBreakpoint" />
-      <keyword name="DebuggerInterfacePython3.remoteBreakpointEnable" id="DebuggerInterfacePython3.remoteBreakpointEnable" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteBreakpointEnable" />
-      <keyword name="DebuggerInterfacePython3.remoteBreakpointIgnore" id="DebuggerInterfacePython3.remoteBreakpointIgnore" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteBreakpointIgnore" />
-      <keyword name="DebuggerInterfacePython3.remoteCapabilities" id="DebuggerInterfacePython3.remoteCapabilities" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteCapabilities" />
-      <keyword name="DebuggerInterfacePython3.remoteClientSetFilter" id="DebuggerInterfacePython3.remoteClientSetFilter" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteClientSetFilter" />
-      <keyword name="DebuggerInterfacePython3.remoteClientVariable" id="DebuggerInterfacePython3.remoteClientVariable" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteClientVariable" />
-      <keyword name="DebuggerInterfacePython3.remoteClientVariables" id="DebuggerInterfacePython3.remoteClientVariables" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteClientVariables" />
-      <keyword name="DebuggerInterfacePython3.remoteCompletion" id="DebuggerInterfacePython3.remoteCompletion" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteCompletion" />
-      <keyword name="DebuggerInterfacePython3.remoteContinue" id="DebuggerInterfacePython3.remoteContinue" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteContinue" />
-      <keyword name="DebuggerInterfacePython3.remoteCoverage" id="DebuggerInterfacePython3.remoteCoverage" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteCoverage" />
-      <keyword name="DebuggerInterfacePython3.remoteEnvironment" id="DebuggerInterfacePython3.remoteEnvironment" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteEnvironment" />
-      <keyword name="DebuggerInterfacePython3.remoteLoad" id="DebuggerInterfacePython3.remoteLoad" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteLoad" />
-      <keyword name="DebuggerInterfacePython3.remoteMoveIP" id="DebuggerInterfacePython3.remoteMoveIP" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteMoveIP" />
-      <keyword name="DebuggerInterfacePython3.remoteProfile" id="DebuggerInterfacePython3.remoteProfile" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteProfile" />
-      <keyword name="DebuggerInterfacePython3.remoteRawInput" id="DebuggerInterfacePython3.remoteRawInput" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteRawInput" />
-      <keyword name="DebuggerInterfacePython3.remoteRun" id="DebuggerInterfacePython3.remoteRun" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteRun" />
-      <keyword name="DebuggerInterfacePython3.remoteSetThread" id="DebuggerInterfacePython3.remoteSetThread" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteSetThread" />
-      <keyword name="DebuggerInterfacePython3.remoteStatement" id="DebuggerInterfacePython3.remoteStatement" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteStatement" />
-      <keyword name="DebuggerInterfacePython3.remoteStep" id="DebuggerInterfacePython3.remoteStep" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteStep" />
-      <keyword name="DebuggerInterfacePython3.remoteStepOut" id="DebuggerInterfacePython3.remoteStepOut" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteStepOut" />
-      <keyword name="DebuggerInterfacePython3.remoteStepOver" id="DebuggerInterfacePython3.remoteStepOver" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteStepOver" />
-      <keyword name="DebuggerInterfacePython3.remoteStepQuit" id="DebuggerInterfacePython3.remoteStepQuit" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteStepQuit" />
-      <keyword name="DebuggerInterfacePython3.remoteThreadList" id="DebuggerInterfacePython3.remoteThreadList" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteThreadList" />
-      <keyword name="DebuggerInterfacePython3.remoteUTPrepare" id="DebuggerInterfacePython3.remoteUTPrepare" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteUTPrepare" />
-      <keyword name="DebuggerInterfacePython3.remoteUTRun" id="DebuggerInterfacePython3.remoteUTRun" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteUTRun" />
-      <keyword name="DebuggerInterfacePython3.remoteUTStop" id="DebuggerInterfacePython3.remoteUTStop" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteUTStop" />
-      <keyword name="DebuggerInterfacePython3.remoteWatchpoint" id="DebuggerInterfacePython3.remoteWatchpoint" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteWatchpoint" />
-      <keyword name="DebuggerInterfacePython3.remoteWatchpointEnable" id="DebuggerInterfacePython3.remoteWatchpointEnable" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteWatchpointEnable" />
-      <keyword name="DebuggerInterfacePython3.remoteWatchpointIgnore" id="DebuggerInterfacePython3.remoteWatchpointIgnore" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.remoteWatchpointIgnore" />
-      <keyword name="DebuggerInterfacePython3.setCallTraceEnabled" id="DebuggerInterfacePython3.setCallTraceEnabled" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.setCallTraceEnabled" />
-      <keyword name="DebuggerInterfacePython3.shutdown" id="DebuggerInterfacePython3.shutdown" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.shutdown" />
-      <keyword name="DebuggerInterfacePython3.startRemote" id="DebuggerInterfacePython3.startRemote" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.startRemote" />
-      <keyword name="DebuggerInterfacePython3.startRemoteForProject" id="DebuggerInterfacePython3.startRemoteForProject" ref="eric6.Debugger.DebuggerInterfacePython3.html#DebuggerInterfacePython3.startRemoteForProject" />
       <keyword name="DebuggerPropertiesDialog" id="DebuggerPropertiesDialog" ref="eric6.Project.DebuggerPropertiesDialog.html#DebuggerPropertiesDialog" />
       <keyword name="DebuggerPropertiesDialog (Constructor)" id="DebuggerPropertiesDialog (Constructor)" ref="eric6.Project.DebuggerPropertiesDialog.html#DebuggerPropertiesDialog.__init__" />
       <keyword name="DebuggerPropertiesDialog (Module)" id="DebuggerPropertiesDialog (Module)" ref="eric6.Project.DebuggerPropertiesDialog.html" />
@@ -16825,8 +16778,8 @@
       <keyword name="createConfigurationPage" id="createConfigurationPage" ref="eric6.Plugins.PluginVcsPySvn.html#createConfigurationPage" />
       <keyword name="createConfigurationPage" id="createConfigurationPage" ref="eric6.Plugins.PluginVcsSubversion.html#createConfigurationPage" />
       <keyword name="createDebuggerInterfaceNone" id="createDebuggerInterfaceNone" ref="eric6.Debugger.DebuggerInterfaceNone.html#createDebuggerInterfaceNone" />
-      <keyword name="createDebuggerInterfacePython2" id="createDebuggerInterfacePython2" ref="eric6.Debugger.DebuggerInterfacePython2.html#createDebuggerInterfacePython2" />
-      <keyword name="createDebuggerInterfacePython3" id="createDebuggerInterfacePython3" ref="eric6.Debugger.DebuggerInterfacePython3.html#createDebuggerInterfacePython3" />
+      <keyword name="createDebuggerInterfacePython2" id="createDebuggerInterfacePython2" ref="eric6.Debugger.DebuggerInterfacePython.html#createDebuggerInterfacePython2" />
+      <keyword name="createDebuggerInterfacePython3" id="createDebuggerInterfacePython3" ref="eric6.Debugger.DebuggerInterfacePython.html#createDebuggerInterfacePython3" />
       <keyword name="createDefaultConfig" id="createDefaultConfig" ref="eric6.Plugins.VcsPlugins.vcsPySvn.SvnUtilities.html#createDefaultConfig" />
       <keyword name="createDefaultConfig" id="createDefaultConfig" ref="eric6.Plugins.VcsPlugins.vcsSubversion.SvnUtilities.html#createDefaultConfig" />
       <keyword name="createGlobalPluginsDir" id="createGlobalPluginsDir" ref="eric6.install.html#createGlobalPluginsDir" />
@@ -17060,8 +17013,7 @@
       <keyword name="getQtTranslationsDir" id="getQtTranslationsDir" ref="eric6.Preferences.__init__.html#getQtTranslationsDir" />
       <keyword name="getRealName" id="getRealName" ref="eric6.Utilities.__init__.html#getRealName" />
       <keyword name="getRegistryData" id="getRegistryData" ref="eric6.Debugger.DebuggerInterfaceNone.html#getRegistryData" />
-      <keyword name="getRegistryData" id="getRegistryData" ref="eric6.Debugger.DebuggerInterfacePython2.html#getRegistryData" />
-      <keyword name="getRegistryData" id="getRegistryData" ref="eric6.Debugger.DebuggerInterfacePython3.html#getRegistryData" />
+      <keyword name="getRegistryData" id="getRegistryData" ref="eric6.Debugger.DebuggerInterfacePython.html#getRegistryData" />
       <keyword name="getSaveFileFiltersList" id="getSaveFileFiltersList" ref="eric6.QScintilla.Lexers.__init__.html#getSaveFileFiltersList" />
       <keyword name="getSaveFileName" id="getSaveFileName" ref="eric6.E5Gui.E5FileDialog.html#getSaveFileName" />
       <keyword name="getSaveFileNameAndFilter" id="getSaveFileNameAndFilter" ref="eric6.E5Gui.E5FileDialog.html#getSaveFileNameAndFilter" />
@@ -17510,8 +17462,8 @@
       <file>eric6.Debugger.DebugUI.html</file>
       <file>eric6.Debugger.DebugViewer.html</file>
       <file>eric6.Debugger.DebuggerInterfaceNone.html</file>
+      <file>eric6.Debugger.DebuggerInterfacePython.html</file>
       <file>eric6.Debugger.DebuggerInterfacePython2.html</file>
-      <file>eric6.Debugger.DebuggerInterfacePython3.html</file>
       <file>eric6.Debugger.EditBreakpointDialog.html</file>
       <file>eric6.Debugger.EditWatchpointDialog.html</file>
       <file>eric6.Debugger.ExceptionLogger.html</file>
--- a/Documentation/Source/eric6.Debugger.DebugServer.html	Sat Aug 26 17:10:43 2017 +0200
+++ b/Documentation/Source/eric6.Debugger.DebugServer.html	Sat Aug 26 19:26:07 2017 +0200
@@ -1106,11 +1106,11 @@
         Public slot to handle the preferencesChanged signal.
 </p><a NAME="DebugServer.registerDebuggerInterface" ID="DebugServer.registerDebuggerInterface"></a>
 <h4>DebugServer.registerDebuggerInterface</h4>
-<b>registerDebuggerInterface</b>(<i>name, getRegistryData</i>)
+<b>registerDebuggerInterface</b>(<i>interfaceName, getRegistryData</i>)
 <p>
         Public method to register a debugger interface.
 </p><dl>
-<dt><i>name</i> (str)</dt>
+<dt><i>interfaceName</i> (str)</dt>
 <dd>
 name of the debugger interface
 </dd><dt><i>getRegistryData</i> (function)</dt>
@@ -1848,13 +1848,13 @@
 </dd>
 </dl><a NAME="DebugServer.unregisterDebuggerInterface" ID="DebugServer.unregisterDebuggerInterface"></a>
 <h4>DebugServer.unregisterDebuggerInterface</h4>
-<b>unregisterDebuggerInterface</b>(<i>name</i>)
+<b>unregisterDebuggerInterface</b>(<i>interfaceName</i>)
 <p>
         Public method to unregister a debugger interface.
 </p><dl>
-<dt><i>name</i> (str)</dt>
+<dt><i>interfaceName</i> (str)</dt>
 <dd>
-name of the debugger interface
+interfaceName of the debugger interface
 </dd>
 </dl>
 <div align="right"><a href="#top">Up</a></div>
--- a/Documentation/Source/eric6.Debugger.DebuggerInterfaceNone.html	Sat Aug 26 17:10:43 2017 +0200
+++ b/Documentation/Source/eric6.Debugger.DebuggerInterfaceNone.html	Sat Aug 26 19:26:07 2017 +0200
@@ -41,7 +41,7 @@
 <td>Module function to create a debugger interface instance.</td>
 </tr><tr>
 <td><a href="#getRegistryData">getRegistryData</a></td>
-<td>Module functionto get characterizing data for the debugger interface.</td>
+<td>Module function to get characterizing data for the debugger interface.</td>
 </tr>
 </table>
 <hr /><hr />
@@ -723,7 +723,7 @@
 </dl><dl>
 <dt>Return Type:</dt>
 <dd>
-DebuggerInterfacePython
+DebuggerInterfaceNone
 </dd>
 </dl>
 <div align="right"><a href="#top">Up</a></div>
@@ -732,17 +732,18 @@
 <h2>getRegistryData</h2>
 <b>getRegistryData</b>(<i></i>)
 <p>
-    Module functionto get characterizing data for the debugger interface.
+    Module function to get characterizing data for the debugger interface.
 </p><dl>
 <dt>Returns:</dt>
 <dd>
-tuple containing  client type, client capabilities, client file
-        type associations and reference to creation function
+list of tuples containing the client type, the client capabilities,
+        the client file type associations and a reference to the creation
+        function
 </dd>
 </dl><dl>
 <dt>Return Type:</dt>
 <dd>
-tuple of (str, int, list of str, function)
+list of tuple of (str, int, list of str, function)
 </dd>
 </dl>
 <div align="right"><a href="#top">Up</a></div>
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/Documentation/Source/eric6.Debugger.DebuggerInterfacePython.html	Sat Aug 26 19:26:07 2017 +0200
@@ -0,0 +1,897 @@
+<!DOCTYPE html>
+<html><head>
+<title>eric6.Debugger.DebuggerInterfacePython</title>
+<meta charset="UTF-8">
+<style>
+body {
+    background: #EDECE6;
+    margin: 0em 1em 10em 1em;
+    color: black;
+}
+
+h1 { color: white; background: #85774A; }
+h2 { color: white; background: #85774A; }
+h3 { color: white; background: #9D936E; }
+h4 { color: white; background: #9D936E; }
+    
+a { color: #BA6D36; }
+
+</style>
+</head>
+<body><a NAME="top" ID="top"></a>
+<h1>eric6.Debugger.DebuggerInterfacePython</h1>
+<p>
+Module implementing the Python3 debugger interface for the debug server.
+</p>
+<h3>Global Attributes</h3>
+<table>
+<tr><td>ClientDefaultCapabilities</td></tr>
+</table>
+<h3>Classes</h3>
+<table>
+<tr>
+<td><a href="#DebuggerInterfacePython">DebuggerInterfacePython</a></td>
+<td>Class implementing the debugger interface for the debug server for Python 2 and Python 3.</td>
+</tr>
+</table>
+<h3>Functions</h3>
+<table>
+<tr>
+<td><a href="#createDebuggerInterfacePython2">createDebuggerInterfacePython2</a></td>
+<td>Module function to create a debugger interface instance.</td>
+</tr><tr>
+<td><a href="#createDebuggerInterfacePython3">createDebuggerInterfacePython3</a></td>
+<td>Module function to create a debugger interface instance.</td>
+</tr><tr>
+<td><a href="#getRegistryData">getRegistryData</a></td>
+<td>Module function to get characterizing data for the supported debugger interfaces.</td>
+</tr>
+</table>
+<hr /><hr />
+<a NAME="DebuggerInterfacePython" ID="DebuggerInterfacePython"></a>
+<h2>DebuggerInterfacePython</h2>
+<p>
+    Class implementing the debugger interface for the debug server for Python 2
+    and Python 3.
+</p>
+<h3>Derived from</h3>
+QObject
+<h3>Class Attributes</h3>
+<table>
+<tr><td>None</td></tr>
+</table>
+<h3>Class Methods</h3>
+<table>
+<tr><td>None</td></tr>
+</table>
+<h3>Methods</h3>
+<table>
+<tr>
+<td><a href="#DebuggerInterfacePython.__init__">DebuggerInterfacePython</a></td>
+<td>Constructor</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.__askForkTo">__askForkTo</a></td>
+<td>Private method to ask the user which branch of a fork to follow.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.__handleJsonCommand">__handleJsonCommand</a></td>
+<td>Private method to handle a command or response serialized as a JSON string.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.__identityTranslation">__identityTranslation</a></td>
+<td>Private method to perform the identity path translation.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.__parseClientLine">__parseClientLine</a></td>
+<td>Private method to handle data from the client.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.__remoteTranslation">__remoteTranslation</a></td>
+<td>Private method to perform the path translation.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.__sendJsonCommand">__sendJsonCommand</a></td>
+<td>Private method to send a single command to the client.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.__startProcess">__startProcess</a></td>
+<td>Private method to start the debugger client process.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.flush">flush</a></td>
+<td>Public slot to flush the queue.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.getClientCapabilities">getClientCapabilities</a></td>
+<td>Public method to retrieve the debug clients capabilities.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.isConnected">isConnected</a></td>
+<td>Public method to test, if a debug client has connected.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.newConnection">newConnection</a></td>
+<td>Public slot to handle a new connection.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteBanner">remoteBanner</a></td>
+<td>Public slot to get the banner info of the remote client.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteBreakpoint">remoteBreakpoint</a></td>
+<td>Public method to set or clear a breakpoint.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteBreakpointEnable">remoteBreakpointEnable</a></td>
+<td>Public method to enable or disable a breakpoint.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteBreakpointIgnore">remoteBreakpointIgnore</a></td>
+<td>Public method to ignore a breakpoint the next couple of occurrences.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteCapabilities">remoteCapabilities</a></td>
+<td>Public slot to get the debug clients capabilities.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteClientSetFilter">remoteClientSetFilter</a></td>
+<td>Public method to set a variables filter list.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteClientVariable">remoteClientVariable</a></td>
+<td>Public method to request the variables of the debugged program.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteClientVariables">remoteClientVariables</a></td>
+<td>Public method to request the variables of the debugged program.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteCompletion">remoteCompletion</a></td>
+<td>Public slot to get the a list of possible commandline completions from the remote client.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteContinue">remoteContinue</a></td>
+<td>Public method to continue the debugged program.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteCoverage">remoteCoverage</a></td>
+<td>Public method to load a new program to collect coverage data.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteEnvironment">remoteEnvironment</a></td>
+<td>Public method to set the environment for a program to debug, run, ...</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteLoad">remoteLoad</a></td>
+<td>Public method to load a new program to debug.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteMoveIP">remoteMoveIP</a></td>
+<td>Public method to move the instruction pointer to a different line.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteProfile">remoteProfile</a></td>
+<td>Public method to load a new program to collect profiling data.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteRawInput">remoteRawInput</a></td>
+<td>Public method to send the raw input to the debugged program.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteRun">remoteRun</a></td>
+<td>Public method to load a new program to run.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteSetThread">remoteSetThread</a></td>
+<td>Public method to request to set the given thread as current thread.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteStatement">remoteStatement</a></td>
+<td>Public method to execute a Python statement.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteStep">remoteStep</a></td>
+<td>Public method to single step the debugged program.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteStepOut">remoteStepOut</a></td>
+<td>Public method to step out the debugged program.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteStepOver">remoteStepOver</a></td>
+<td>Public method to step over the debugged program.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteStepQuit">remoteStepQuit</a></td>
+<td>Public method to stop the debugged program.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteThreadList">remoteThreadList</a></td>
+<td>Public method to request the list of threads from the client.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteUTPrepare">remoteUTPrepare</a></td>
+<td>Public method to prepare a new unittest run.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteUTRun">remoteUTRun</a></td>
+<td>Public method to start a unittest run.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteUTStop">remoteUTStop</a></td>
+<td>Public method to stop a unittest run.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteWatchpoint">remoteWatchpoint</a></td>
+<td>Public method to set or clear a watch expression.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteWatchpointEnable">remoteWatchpointEnable</a></td>
+<td>Public method to enable or disable a watch expression.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.remoteWatchpointIgnore">remoteWatchpointIgnore</a></td>
+<td>Public method to ignore a watch expression the next couple of occurrences.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.setCallTraceEnabled">setCallTraceEnabled</a></td>
+<td>Public method to set the call trace state.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.shutdown">shutdown</a></td>
+<td>Public method to cleanly shut down.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.startRemote">startRemote</a></td>
+<td>Public method to start a remote Python interpreter.</td>
+</tr><tr>
+<td><a href="#DebuggerInterfacePython.startRemoteForProject">startRemoteForProject</a></td>
+<td>Public method to start a remote Python interpreter for a project.</td>
+</tr>
+</table>
+<h3>Static Methods</h3>
+<table>
+<tr><td>None</td></tr>
+</table>
+<a NAME="DebuggerInterfacePython.__init__" ID="DebuggerInterfacePython.__init__"></a>
+<h4>DebuggerInterfacePython (Constructor)</h4>
+<b>DebuggerInterfacePython</b>(<i>debugServer, passive, pythonVariant</i>)
+<p>
+        Constructor
+</p><dl>
+<dt><i>debugServer</i> (DebugServer)</dt>
+<dd>
+reference to the debug server
+</dd><dt><i>passive</i> (bool)</dt>
+<dd>
+flag indicating passive connection mode
+</dd><dt><i>pythonVariant</i> (str (one of Python2 or Python3))</dt>
+<dd>
+Python variant to instantiate for
+</dd>
+</dl><a NAME="DebuggerInterfacePython.__askForkTo" ID="DebuggerInterfacePython.__askForkTo"></a>
+<h4>DebuggerInterfacePython.__askForkTo</h4>
+<b>__askForkTo</b>(<i></i>)
+<p>
+        Private method to ask the user which branch of a fork to follow.
+</p><a NAME="DebuggerInterfacePython.__handleJsonCommand" ID="DebuggerInterfacePython.__handleJsonCommand"></a>
+<h4>DebuggerInterfacePython.__handleJsonCommand</h4>
+<b>__handleJsonCommand</b>(<i>jsonStr</i>)
+<p>
+        Private method to handle a command or response serialized as a
+        JSON string.
+</p><dl>
+<dt><i>jsonStr</i> (str)</dt>
+<dd>
+string containing the command or response received
+            from the debug backend
+</dd>
+</dl><a NAME="DebuggerInterfacePython.__identityTranslation" ID="DebuggerInterfacePython.__identityTranslation"></a>
+<h4>DebuggerInterfacePython.__identityTranslation</h4>
+<b>__identityTranslation</b>(<i>fn, remote2local=True</i>)
+<p>
+        Private method to perform the identity path translation.
+</p><dl>
+<dt><i>fn</i></dt>
+<dd>
+filename to be translated (string)
+</dd><dt><i>remote2local</i></dt>
+<dd>
+flag indicating the direction of translation
+            (False = local to remote, True = remote to local [default])
+</dd>
+</dl><dl>
+<dt>Returns:</dt>
+<dd>
+translated filename (string)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.__parseClientLine" ID="DebuggerInterfacePython.__parseClientLine"></a>
+<h4>DebuggerInterfacePython.__parseClientLine</h4>
+<b>__parseClientLine</b>(<i></i>)
+<p>
+        Private method to handle data from the client.
+</p><a NAME="DebuggerInterfacePython.__remoteTranslation" ID="DebuggerInterfacePython.__remoteTranslation"></a>
+<h4>DebuggerInterfacePython.__remoteTranslation</h4>
+<b>__remoteTranslation</b>(<i>fn, remote2local=True</i>)
+<p>
+        Private method to perform the path translation.
+</p><dl>
+<dt><i>fn</i></dt>
+<dd>
+filename to be translated (string)
+</dd><dt><i>remote2local</i></dt>
+<dd>
+flag indicating the direction of translation
+            (False = local to remote, True = remote to local [default])
+</dd>
+</dl><dl>
+<dt>Returns:</dt>
+<dd>
+translated filename (string)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.__sendJsonCommand" ID="DebuggerInterfacePython.__sendJsonCommand"></a>
+<h4>DebuggerInterfacePython.__sendJsonCommand</h4>
+<b>__sendJsonCommand</b>(<i>command, params</i>)
+<p>
+        Private method to send a single command to the client.
+</p><dl>
+<dt><i>command</i> (str)</dt>
+<dd>
+command name to be sent
+</dd><dt><i>params</i> (dict)</dt>
+<dd>
+dictionary of named parameters for the command
+</dd>
+</dl><a NAME="DebuggerInterfacePython.__startProcess" ID="DebuggerInterfacePython.__startProcess"></a>
+<h4>DebuggerInterfacePython.__startProcess</h4>
+<b>__startProcess</b>(<i>program, arguments, environment=None</i>)
+<p>
+        Private method to start the debugger client process.
+</p><dl>
+<dt><i>program</i></dt>
+<dd>
+name of the executable to start (string)
+</dd><dt><i>arguments</i></dt>
+<dd>
+arguments to be passed to the program (list of string)
+</dd><dt><i>environment</i></dt>
+<dd>
+dictionary of environment settings to pass
+            (dict of string)
+</dd>
+</dl><dl>
+<dt>Returns:</dt>
+<dd>
+the process object (QProcess) or None
+</dd>
+</dl><a NAME="DebuggerInterfacePython.flush" ID="DebuggerInterfacePython.flush"></a>
+<h4>DebuggerInterfacePython.flush</h4>
+<b>flush</b>(<i></i>)
+<p>
+        Public slot to flush the queue.
+</p><a NAME="DebuggerInterfacePython.getClientCapabilities" ID="DebuggerInterfacePython.getClientCapabilities"></a>
+<h4>DebuggerInterfacePython.getClientCapabilities</h4>
+<b>getClientCapabilities</b>(<i></i>)
+<p>
+        Public method to retrieve the debug clients capabilities.
+</p><dl>
+<dt>Returns:</dt>
+<dd>
+debug client capabilities (integer)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.isConnected" ID="DebuggerInterfacePython.isConnected"></a>
+<h4>DebuggerInterfacePython.isConnected</h4>
+<b>isConnected</b>(<i></i>)
+<p>
+        Public method to test, if a debug client has connected.
+</p><dl>
+<dt>Returns:</dt>
+<dd>
+flag indicating the connection status (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.newConnection" ID="DebuggerInterfacePython.newConnection"></a>
+<h4>DebuggerInterfacePython.newConnection</h4>
+<b>newConnection</b>(<i>sock</i>)
+<p>
+        Public slot to handle a new connection.
+</p><dl>
+<dt><i>sock</i></dt>
+<dd>
+reference to the socket object (QTcpSocket)
+</dd>
+</dl><dl>
+<dt>Returns:</dt>
+<dd>
+flag indicating success (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteBanner" ID="DebuggerInterfacePython.remoteBanner"></a>
+<h4>DebuggerInterfacePython.remoteBanner</h4>
+<b>remoteBanner</b>(<i></i>)
+<p>
+        Public slot to get the banner info of the remote client.
+</p><a NAME="DebuggerInterfacePython.remoteBreakpoint" ID="DebuggerInterfacePython.remoteBreakpoint"></a>
+<h4>DebuggerInterfacePython.remoteBreakpoint</h4>
+<b>remoteBreakpoint</b>(<i>fn, line, setBreakpoint, cond=None, temp=False</i>)
+<p>
+        Public method to set or clear a breakpoint.
+</p><dl>
+<dt><i>fn</i></dt>
+<dd>
+filename the breakpoint belongs to (string)
+</dd><dt><i>line</i></dt>
+<dd>
+linenumber of the breakpoint (int)
+</dd><dt><i>setBreakpoint</i></dt>
+<dd>
+flag indicating setting or resetting a
+            breakpoint (boolean)
+</dd><dt><i>cond</i></dt>
+<dd>
+condition of the breakpoint (string)
+</dd><dt><i>temp</i></dt>
+<dd>
+flag indicating a temporary breakpoint (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteBreakpointEnable" ID="DebuggerInterfacePython.remoteBreakpointEnable"></a>
+<h4>DebuggerInterfacePython.remoteBreakpointEnable</h4>
+<b>remoteBreakpointEnable</b>(<i>fn, line, enable</i>)
+<p>
+        Public method to enable or disable a breakpoint.
+</p><dl>
+<dt><i>fn</i></dt>
+<dd>
+filename the breakpoint belongs to (string)
+</dd><dt><i>line</i></dt>
+<dd>
+linenumber of the breakpoint (int)
+</dd><dt><i>enable</i></dt>
+<dd>
+flag indicating enabling or disabling a breakpoint
+            (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteBreakpointIgnore" ID="DebuggerInterfacePython.remoteBreakpointIgnore"></a>
+<h4>DebuggerInterfacePython.remoteBreakpointIgnore</h4>
+<b>remoteBreakpointIgnore</b>(<i>fn, line, count</i>)
+<p>
+        Public method to ignore a breakpoint the next couple of occurrences.
+</p><dl>
+<dt><i>fn</i></dt>
+<dd>
+filename the breakpoint belongs to (string)
+</dd><dt><i>line</i></dt>
+<dd>
+linenumber of the breakpoint (int)
+</dd><dt><i>count</i></dt>
+<dd>
+number of occurrences to ignore (int)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteCapabilities" ID="DebuggerInterfacePython.remoteCapabilities"></a>
+<h4>DebuggerInterfacePython.remoteCapabilities</h4>
+<b>remoteCapabilities</b>(<i></i>)
+<p>
+        Public slot to get the debug clients capabilities.
+</p><a NAME="DebuggerInterfacePython.remoteClientSetFilter" ID="DebuggerInterfacePython.remoteClientSetFilter"></a>
+<h4>DebuggerInterfacePython.remoteClientSetFilter</h4>
+<b>remoteClientSetFilter</b>(<i>scope, filterStr</i>)
+<p>
+        Public method to set a variables filter list.
+</p><dl>
+<dt><i>scope</i></dt>
+<dd>
+the scope of the variables (0 = local, 1 = global)
+</dd><dt><i>filterStr</i></dt>
+<dd>
+regexp string for variable names to filter out
+            (string)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteClientVariable" ID="DebuggerInterfacePython.remoteClientVariable"></a>
+<h4>DebuggerInterfacePython.remoteClientVariable</h4>
+<b>remoteClientVariable</b>(<i>scope, filterList, var, framenr=0</i>)
+<p>
+        Public method to request the variables of the debugged program.
+</p><dl>
+<dt><i>scope</i></dt>
+<dd>
+the scope of the variables (0 = local, 1 = global)
+</dd><dt><i>filterList</i></dt>
+<dd>
+list of variable types to filter out (list of int)
+</dd><dt><i>var</i></dt>
+<dd>
+list encoded name of variable to retrieve (string)
+</dd><dt><i>framenr</i></dt>
+<dd>
+framenumber of the variables to retrieve (int)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteClientVariables" ID="DebuggerInterfacePython.remoteClientVariables"></a>
+<h4>DebuggerInterfacePython.remoteClientVariables</h4>
+<b>remoteClientVariables</b>(<i>scope, filterList, framenr=0</i>)
+<p>
+        Public method to request the variables of the debugged program.
+</p><dl>
+<dt><i>scope</i></dt>
+<dd>
+the scope of the variables (0 = local, 1 = global)
+</dd><dt><i>filterList</i></dt>
+<dd>
+list of variable types to filter out (list of int)
+</dd><dt><i>framenr</i></dt>
+<dd>
+framenumber of the variables to retrieve (int)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteCompletion" ID="DebuggerInterfacePython.remoteCompletion"></a>
+<h4>DebuggerInterfacePython.remoteCompletion</h4>
+<b>remoteCompletion</b>(<i>text</i>)
+<p>
+        Public slot to get the a list of possible commandline completions
+        from the remote client.
+</p><dl>
+<dt><i>text</i></dt>
+<dd>
+the text to be completed (string)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteContinue" ID="DebuggerInterfacePython.remoteContinue"></a>
+<h4>DebuggerInterfacePython.remoteContinue</h4>
+<b>remoteContinue</b>(<i>special=False</i>)
+<p>
+        Public method to continue the debugged program.
+</p><dl>
+<dt><i>special</i></dt>
+<dd>
+flag indicating a special continue operation
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteCoverage" ID="DebuggerInterfacePython.remoteCoverage"></a>
+<h4>DebuggerInterfacePython.remoteCoverage</h4>
+<b>remoteCoverage</b>(<i>fn, argv, wd, erase=False</i>)
+<p>
+        Public method to load a new program to collect coverage data.
+</p><dl>
+<dt><i>fn</i></dt>
+<dd>
+the filename to run (string)
+</dd><dt><i>argv</i></dt>
+<dd>
+the commandline arguments to pass to the program (string)
+</dd><dt><i>wd</i></dt>
+<dd>
+the working directory for the program (string)
+</dd><dt><i>erase=</i></dt>
+<dd>
+flag indicating that coverage info should be
+            cleared first (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteEnvironment" ID="DebuggerInterfacePython.remoteEnvironment"></a>
+<h4>DebuggerInterfacePython.remoteEnvironment</h4>
+<b>remoteEnvironment</b>(<i>env</i>)
+<p>
+        Public method to set the environment for a program to debug, run, ...
+</p><dl>
+<dt><i>env</i></dt>
+<dd>
+environment settings (dictionary)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteLoad" ID="DebuggerInterfacePython.remoteLoad"></a>
+<h4>DebuggerInterfacePython.remoteLoad</h4>
+<b>remoteLoad</b>(<i>fn, argv, wd, traceInterpreter=False, autoContinue=True, autoFork=False, forkChild=False</i>)
+<p>
+        Public method to load a new program to debug.
+</p><dl>
+<dt><i>fn</i></dt>
+<dd>
+the filename to debug (string)
+</dd><dt><i>argv</i></dt>
+<dd>
+the commandline arguments to pass to the program (string)
+</dd><dt><i>wd</i></dt>
+<dd>
+the working directory for the program (string)
+</dd><dt><i>traceInterpreter=</i></dt>
+<dd>
+flag indicating if the interpreter library
+            should be traced as well (boolean)
+</dd><dt><i>autoContinue=</i></dt>
+<dd>
+flag indicating, that the debugger should not
+            stop at the first executable line (boolean)
+</dd><dt><i>autoFork=</i></dt>
+<dd>
+flag indicating the automatic fork mode (boolean)
+</dd><dt><i>forkChild=</i></dt>
+<dd>
+flag indicating to debug the child after forking
+            (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteMoveIP" ID="DebuggerInterfacePython.remoteMoveIP"></a>
+<h4>DebuggerInterfacePython.remoteMoveIP</h4>
+<b>remoteMoveIP</b>(<i>line</i>)
+<p>
+        Public method to move the instruction pointer to a different line.
+</p><dl>
+<dt><i>line</i></dt>
+<dd>
+the new line, where execution should be continued
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteProfile" ID="DebuggerInterfacePython.remoteProfile"></a>
+<h4>DebuggerInterfacePython.remoteProfile</h4>
+<b>remoteProfile</b>(<i>fn, argv, wd, erase=False</i>)
+<p>
+        Public method to load a new program to collect profiling data.
+</p><dl>
+<dt><i>fn</i></dt>
+<dd>
+the filename to run (string)
+</dd><dt><i>argv</i></dt>
+<dd>
+the commandline arguments to pass to the program (string)
+</dd><dt><i>wd</i></dt>
+<dd>
+the working directory for the program (string)
+</dd><dt><i>erase=</i></dt>
+<dd>
+flag indicating that timing info should be cleared
+            first (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteRawInput" ID="DebuggerInterfacePython.remoteRawInput"></a>
+<h4>DebuggerInterfacePython.remoteRawInput</h4>
+<b>remoteRawInput</b>(<i>s</i>)
+<p>
+        Public method to send the raw input to the debugged program.
+</p><dl>
+<dt><i>s</i></dt>
+<dd>
+the raw input (string)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteRun" ID="DebuggerInterfacePython.remoteRun"></a>
+<h4>DebuggerInterfacePython.remoteRun</h4>
+<b>remoteRun</b>(<i>fn, argv, wd, autoFork=False, forkChild=False</i>)
+<p>
+        Public method to load a new program to run.
+</p><dl>
+<dt><i>fn</i></dt>
+<dd>
+the filename to run (string)
+</dd><dt><i>argv</i></dt>
+<dd>
+the commandline arguments to pass to the program (string)
+</dd><dt><i>wd</i></dt>
+<dd>
+the working directory for the program (string)
+</dd><dt><i>autoFork=</i></dt>
+<dd>
+flag indicating the automatic fork mode (boolean)
+</dd><dt><i>forkChild=</i></dt>
+<dd>
+flag indicating to debug the child after forking
+            (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteSetThread" ID="DebuggerInterfacePython.remoteSetThread"></a>
+<h4>DebuggerInterfacePython.remoteSetThread</h4>
+<b>remoteSetThread</b>(<i>tid</i>)
+<p>
+        Public method to request to set the given thread as current thread.
+</p><dl>
+<dt><i>tid</i></dt>
+<dd>
+id of the thread (integer)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteStatement" ID="DebuggerInterfacePython.remoteStatement"></a>
+<h4>DebuggerInterfacePython.remoteStatement</h4>
+<b>remoteStatement</b>(<i>stmt</i>)
+<p>
+        Public method to execute a Python statement.
+</p><dl>
+<dt><i>stmt</i></dt>
+<dd>
+the Python statement to execute (string). It
+              should not have a trailing newline.
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteStep" ID="DebuggerInterfacePython.remoteStep"></a>
+<h4>DebuggerInterfacePython.remoteStep</h4>
+<b>remoteStep</b>(<i></i>)
+<p>
+        Public method to single step the debugged program.
+</p><a NAME="DebuggerInterfacePython.remoteStepOut" ID="DebuggerInterfacePython.remoteStepOut"></a>
+<h4>DebuggerInterfacePython.remoteStepOut</h4>
+<b>remoteStepOut</b>(<i></i>)
+<p>
+        Public method to step out the debugged program.
+</p><a NAME="DebuggerInterfacePython.remoteStepOver" ID="DebuggerInterfacePython.remoteStepOver"></a>
+<h4>DebuggerInterfacePython.remoteStepOver</h4>
+<b>remoteStepOver</b>(<i></i>)
+<p>
+        Public method to step over the debugged program.
+</p><a NAME="DebuggerInterfacePython.remoteStepQuit" ID="DebuggerInterfacePython.remoteStepQuit"></a>
+<h4>DebuggerInterfacePython.remoteStepQuit</h4>
+<b>remoteStepQuit</b>(<i></i>)
+<p>
+        Public method to stop the debugged program.
+</p><a NAME="DebuggerInterfacePython.remoteThreadList" ID="DebuggerInterfacePython.remoteThreadList"></a>
+<h4>DebuggerInterfacePython.remoteThreadList</h4>
+<b>remoteThreadList</b>(<i></i>)
+<p>
+        Public method to request the list of threads from the client.
+</p><a NAME="DebuggerInterfacePython.remoteUTPrepare" ID="DebuggerInterfacePython.remoteUTPrepare"></a>
+<h4>DebuggerInterfacePython.remoteUTPrepare</h4>
+<b>remoteUTPrepare</b>(<i>fn, tn, tfn, failed, cov, covname, coverase</i>)
+<p>
+        Public method to prepare a new unittest run.
+</p><dl>
+<dt><i>fn</i></dt>
+<dd>
+the filename to load (string)
+</dd><dt><i>tn</i></dt>
+<dd>
+the testname to load (string)
+</dd><dt><i>tfn</i></dt>
+<dd>
+the test function name to load tests from (string)
+</dd><dt><i>failed</i></dt>
+<dd>
+list of failed test, if only failed test should be run
+            (list of strings)
+</dd><dt><i>cov</i></dt>
+<dd>
+flag indicating collection of coverage data is requested
+            (boolean)
+</dd><dt><i>covname</i></dt>
+<dd>
+filename to be used to assemble the coverage caches
+            filename (string)
+</dd><dt><i>coverase</i></dt>
+<dd>
+flag indicating erasure of coverage data is requested
+            (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteUTRun" ID="DebuggerInterfacePython.remoteUTRun"></a>
+<h4>DebuggerInterfacePython.remoteUTRun</h4>
+<b>remoteUTRun</b>(<i></i>)
+<p>
+        Public method to start a unittest run.
+</p><a NAME="DebuggerInterfacePython.remoteUTStop" ID="DebuggerInterfacePython.remoteUTStop"></a>
+<h4>DebuggerInterfacePython.remoteUTStop</h4>
+<b>remoteUTStop</b>(<i></i>)
+<p>
+        Public method to stop a unittest run.
+</p><a NAME="DebuggerInterfacePython.remoteWatchpoint" ID="DebuggerInterfacePython.remoteWatchpoint"></a>
+<h4>DebuggerInterfacePython.remoteWatchpoint</h4>
+<b>remoteWatchpoint</b>(<i>cond, setWatch, temp=False</i>)
+<p>
+        Public method to set or clear a watch expression.
+</p><dl>
+<dt><i>cond</i></dt>
+<dd>
+expression of the watch expression (string)
+</dd><dt><i>setWatch</i></dt>
+<dd>
+flag indicating setting or resetting a watch expression
+            (boolean)
+</dd><dt><i>temp</i></dt>
+<dd>
+flag indicating a temporary watch expression (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteWatchpointEnable" ID="DebuggerInterfacePython.remoteWatchpointEnable"></a>
+<h4>DebuggerInterfacePython.remoteWatchpointEnable</h4>
+<b>remoteWatchpointEnable</b>(<i>cond, enable</i>)
+<p>
+        Public method to enable or disable a watch expression.
+</p><dl>
+<dt><i>cond</i></dt>
+<dd>
+expression of the watch expression (string)
+</dd><dt><i>enable</i></dt>
+<dd>
+flag indicating enabling or disabling a watch expression
+            (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.remoteWatchpointIgnore" ID="DebuggerInterfacePython.remoteWatchpointIgnore"></a>
+<h4>DebuggerInterfacePython.remoteWatchpointIgnore</h4>
+<b>remoteWatchpointIgnore</b>(<i>cond, count</i>)
+<p>
+        Public method to ignore a watch expression the next couple of
+        occurrences.
+</p><dl>
+<dt><i>cond</i></dt>
+<dd>
+expression of the watch expression (string)
+</dd><dt><i>count</i></dt>
+<dd>
+number of occurrences to ignore (int)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.setCallTraceEnabled" ID="DebuggerInterfacePython.setCallTraceEnabled"></a>
+<h4>DebuggerInterfacePython.setCallTraceEnabled</h4>
+<b>setCallTraceEnabled</b>(<i>on</i>)
+<p>
+        Public method to set the call trace state.
+</p><dl>
+<dt><i>on</i></dt>
+<dd>
+flag indicating to enable the call trace function (boolean)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.shutdown" ID="DebuggerInterfacePython.shutdown"></a>
+<h4>DebuggerInterfacePython.shutdown</h4>
+<b>shutdown</b>(<i></i>)
+<p>
+        Public method to cleanly shut down.
+</p><p>
+        It closes our socket and shuts down
+        the debug client. (Needed on Win OS)
+</p><a NAME="DebuggerInterfacePython.startRemote" ID="DebuggerInterfacePython.startRemote"></a>
+<h4>DebuggerInterfacePython.startRemote</h4>
+<b>startRemote</b>(<i>port, runInConsole</i>)
+<p>
+        Public method to start a remote Python interpreter.
+</p><dl>
+<dt><i>port</i></dt>
+<dd>
+portnumber the debug server is listening on (integer)
+</dd><dt><i>runInConsole</i></dt>
+<dd>
+flag indicating to start the debugger in a
+            console window (boolean)
+</dd>
+</dl><dl>
+<dt>Returns:</dt>
+<dd>
+client process object (QProcess), a flag to indicate
+            a network connection (boolean) and the name of the interpreter
+            in case of a local execution (string)
+</dd>
+</dl><a NAME="DebuggerInterfacePython.startRemoteForProject" ID="DebuggerInterfacePython.startRemoteForProject"></a>
+<h4>DebuggerInterfacePython.startRemoteForProject</h4>
+<b>startRemoteForProject</b>(<i>port, runInConsole</i>)
+<p>
+        Public method to start a remote Python interpreter for a project.
+</p><dl>
+<dt><i>port</i></dt>
+<dd>
+portnumber the debug server is listening on (integer)
+</dd><dt><i>runInConsole</i></dt>
+<dd>
+flag indicating to start the debugger in a
+            console window (boolean)
+</dd>
+</dl><dl>
+<dt>Returns:</dt>
+<dd>
+client process object (QProcess), a flag to indicate
+            a network connection (boolean) and the name of the interpreter
+            in case of a local execution (string)
+</dd>
+</dl>
+<div align="right"><a href="#top">Up</a></div>
+<hr /><hr />
+<a NAME="createDebuggerInterfacePython2" ID="createDebuggerInterfacePython2"></a>
+<h2>createDebuggerInterfacePython2</h2>
+<b>createDebuggerInterfacePython2</b>(<i>debugServer, passive</i>)
+<p>
+    Module function to create a debugger interface instance.
+</p><p>
+
+</p><dl>
+<dt><i>debugServer</i> (DebugServer)</dt>
+<dd>
+reference to the debug server
+</dd><dt><i>passive</i> (bool)</dt>
+<dd>
+flag indicating passive connection mode
+</dd>
+</dl><dl>
+<dt>Returns:</dt>
+<dd>
+instantiated debugger interface
+</dd>
+</dl><dl>
+<dt>Return Type:</dt>
+<dd>
+DebuggerInterfacePython
+</dd>
+</dl>
+<div align="right"><a href="#top">Up</a></div>
+<hr /><hr />
+<a NAME="createDebuggerInterfacePython3" ID="createDebuggerInterfacePython3"></a>
+<h2>createDebuggerInterfacePython3</h2>
+<b>createDebuggerInterfacePython3</b>(<i>debugServer, passive</i>)
+<p>
+    Module function to create a debugger interface instance.
+</p><p>
+
+</p><dl>
+<dt><i>debugServer</i> (DebugServer)</dt>
+<dd>
+reference to the debug server
+</dd><dt><i>passive</i> (bool)</dt>
+<dd>
+flag indicating passive connection mode
+</dd>
+</dl><dl>
+<dt>Returns:</dt>
+<dd>
+instantiated debugger interface
+</dd>
+</dl><dl>
+<dt>Return Type:</dt>
+<dd>
+DebuggerInterfacePython
+</dd>
+</dl>
+<div align="right"><a href="#top">Up</a></div>
+<hr /><hr />
+<a NAME="getRegistryData" ID="getRegistryData"></a>
+<h2>getRegistryData</h2>
+<b>getRegistryData</b>(<i></i>)
+<p>
+    Module function to get characterizing data for the supported debugger
+    interfaces.
+</p><dl>
+<dt>Returns:</dt>
+<dd>
+list of tuples containing the client type, the client capabilities,
+        the client file type associations and a reference to the creation
+        function
+</dd>
+</dl><dl>
+<dt>Return Type:</dt>
+<dd>
+list of tuple of (str, int, list of str, function)
+</dd>
+</dl>
+<div align="right"><a href="#top">Up</a></div>
+<hr />
+</body></html>
\ No newline at end of file
--- a/Documentation/Source/eric6.Debugger.DebuggerInterfacePython2.html	Sat Aug 26 17:10:43 2017 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,860 +0,0 @@
-<!DOCTYPE html>
-<html><head>
-<title>eric6.Debugger.DebuggerInterfacePython2</title>
-<meta charset="UTF-8">
-<style>
-body {
-    background: #EDECE6;
-    margin: 0em 1em 10em 1em;
-    color: black;
-}
-
-h1 { color: white; background: #85774A; }
-h2 { color: white; background: #85774A; }
-h3 { color: white; background: #9D936E; }
-h4 { color: white; background: #9D936E; }
-    
-a { color: #BA6D36; }
-
-</style>
-</head>
-<body><a NAME="top" ID="top"></a>
-<h1>eric6.Debugger.DebuggerInterfacePython2</h1>
-<p>
-Module implementing the Python debugger interface for the debug server.
-</p>
-<h3>Global Attributes</h3>
-<table>
-<tr><td>ClientDefaultCapabilities</td></tr>
-</table>
-<h3>Classes</h3>
-<table>
-<tr>
-<td><a href="#DebuggerInterfacePython2">DebuggerInterfacePython2</a></td>
-<td>Class implementing the Python 2 debugger interface for the debug server.</td>
-</tr>
-</table>
-<h3>Functions</h3>
-<table>
-<tr>
-<td><a href="#createDebuggerInterfacePython2">createDebuggerInterfacePython2</a></td>
-<td>Module function to create a debugger interface instance.</td>
-</tr><tr>
-<td><a href="#getRegistryData">getRegistryData</a></td>
-<td>Module function to get characterizing data for the debugger interface.</td>
-</tr>
-</table>
-<hr /><hr />
-<a NAME="DebuggerInterfacePython2" ID="DebuggerInterfacePython2"></a>
-<h2>DebuggerInterfacePython2</h2>
-<p>
-    Class implementing the Python 2 debugger interface for the debug server.
-</p>
-<h3>Derived from</h3>
-QObject
-<h3>Class Attributes</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Class Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Methods</h3>
-<table>
-<tr>
-<td><a href="#DebuggerInterfacePython2.__init__">DebuggerInterfacePython2</a></td>
-<td>Constructor</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.__askForkTo">__askForkTo</a></td>
-<td>Private method to ask the user which branch of a fork to follow.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.__handleJsonCommand">__handleJsonCommand</a></td>
-<td>Private method to handle a command or response serialized as a JSON string.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.__identityTranslation">__identityTranslation</a></td>
-<td>Private method to perform the identity path translation.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.__parseClientLine">__parseClientLine</a></td>
-<td>Private method to handle data from the client.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.__remoteTranslation">__remoteTranslation</a></td>
-<td>Private method to perform the path translation.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.__sendJsonCommand">__sendJsonCommand</a></td>
-<td>Private method to send a single command to the client.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.__startProcess">__startProcess</a></td>
-<td>Private method to start the debugger client process.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.flush">flush</a></td>
-<td>Public slot to flush the queue.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.getClientCapabilities">getClientCapabilities</a></td>
-<td>Public method to retrieve the debug clients capabilities.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.isConnected">isConnected</a></td>
-<td>Public method to test, if a debug client has connected.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.newConnection">newConnection</a></td>
-<td>Public slot to handle a new connection.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteBanner">remoteBanner</a></td>
-<td>Public slot to get the banner info of the remote client.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteBreakpoint">remoteBreakpoint</a></td>
-<td>Public method to set or clear a breakpoint.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteBreakpointEnable">remoteBreakpointEnable</a></td>
-<td>Public method to enable or disable a breakpoint.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteBreakpointIgnore">remoteBreakpointIgnore</a></td>
-<td>Public method to ignore a breakpoint the next couple of occurrences.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteCapabilities">remoteCapabilities</a></td>
-<td>Public slot to get the debug clients capabilities.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteClientSetFilter">remoteClientSetFilter</a></td>
-<td>Public method to set a variables filter list.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteClientVariable">remoteClientVariable</a></td>
-<td>Public method to request the variables of the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteClientVariables">remoteClientVariables</a></td>
-<td>Public method to request the variables of the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteCompletion">remoteCompletion</a></td>
-<td>Public slot to get the a list of possible commandline completions from the remote client.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteContinue">remoteContinue</a></td>
-<td>Public method to continue the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteCoverage">remoteCoverage</a></td>
-<td>Public method to load a new program to collect coverage data.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteEnvironment">remoteEnvironment</a></td>
-<td>Public method to set the environment for a program to debug, run, ...</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteLoad">remoteLoad</a></td>
-<td>Public method to load a new program to debug.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteMoveIP">remoteMoveIP</a></td>
-<td>Public method to move the instruction pointer to a different line.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteProfile">remoteProfile</a></td>
-<td>Public method to load a new program to collect profiling data.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteRawInput">remoteRawInput</a></td>
-<td>Public method to send the raw input to the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteRun">remoteRun</a></td>
-<td>Public method to load a new program to run.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteSetThread">remoteSetThread</a></td>
-<td>Public method to request to set the given thread as current thread.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteStatement">remoteStatement</a></td>
-<td>Public method to execute a Python statement.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteStep">remoteStep</a></td>
-<td>Public method to single step the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteStepOut">remoteStepOut</a></td>
-<td>Public method to step out the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteStepOver">remoteStepOver</a></td>
-<td>Public method to step over the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteStepQuit">remoteStepQuit</a></td>
-<td>Public method to stop the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteThreadList">remoteThreadList</a></td>
-<td>Public method to request the list of threads from the client.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteUTPrepare">remoteUTPrepare</a></td>
-<td>Public method to prepare a new unittest run.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteUTRun">remoteUTRun</a></td>
-<td>Public method to start a unittest run.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteUTStop">remoteUTStop</a></td>
-<td>Public method to stop a unittest run.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteWatchpoint">remoteWatchpoint</a></td>
-<td>Public method to set or clear a watch expression.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteWatchpointEnable">remoteWatchpointEnable</a></td>
-<td>Public method to enable or disable a watch expression.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.remoteWatchpointIgnore">remoteWatchpointIgnore</a></td>
-<td>Public method to ignore a watch expression the next couple of occurrences.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.setCallTraceEnabled">setCallTraceEnabled</a></td>
-<td>Public method to set the call trace state.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.shutdown">shutdown</a></td>
-<td>Public method to cleanly shut down.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.startRemote">startRemote</a></td>
-<td>Public method to start a remote Python interpreter.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython2.startRemoteForProject">startRemoteForProject</a></td>
-<td>Public method to start a remote Python interpreter for a project.</td>
-</tr>
-</table>
-<h3>Static Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<a NAME="DebuggerInterfacePython2.__init__" ID="DebuggerInterfacePython2.__init__"></a>
-<h4>DebuggerInterfacePython2 (Constructor)</h4>
-<b>DebuggerInterfacePython2</b>(<i>debugServer, passive</i>)
-<p>
-        Constructor
-</p><dl>
-<dt><i>debugServer</i></dt>
-<dd>
-reference to the debug server (DebugServer)
-</dd><dt><i>passive</i></dt>
-<dd>
-flag indicating passive connection mode (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.__askForkTo" ID="DebuggerInterfacePython2.__askForkTo"></a>
-<h4>DebuggerInterfacePython2.__askForkTo</h4>
-<b>__askForkTo</b>(<i></i>)
-<p>
-        Private method to ask the user which branch of a fork to follow.
-</p><a NAME="DebuggerInterfacePython2.__handleJsonCommand" ID="DebuggerInterfacePython2.__handleJsonCommand"></a>
-<h4>DebuggerInterfacePython2.__handleJsonCommand</h4>
-<b>__handleJsonCommand</b>(<i>jsonStr</i>)
-<p>
-        Private method to handle a command or response serialized as a
-        JSON string.
-</p><dl>
-<dt><i>jsonStr</i> (str)</dt>
-<dd>
-string containing the command or response received
-            from the debug backend
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.__identityTranslation" ID="DebuggerInterfacePython2.__identityTranslation"></a>
-<h4>DebuggerInterfacePython2.__identityTranslation</h4>
-<b>__identityTranslation</b>(<i>fn, remote2local=True</i>)
-<p>
-        Private method to perform the identity path translation.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-filename to be translated (string)
-</dd><dt><i>remote2local</i></dt>
-<dd>
-flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-translated filename (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.__parseClientLine" ID="DebuggerInterfacePython2.__parseClientLine"></a>
-<h4>DebuggerInterfacePython2.__parseClientLine</h4>
-<b>__parseClientLine</b>(<i></i>)
-<p>
-        Private method to handle data from the client.
-</p><a NAME="DebuggerInterfacePython2.__remoteTranslation" ID="DebuggerInterfacePython2.__remoteTranslation"></a>
-<h4>DebuggerInterfacePython2.__remoteTranslation</h4>
-<b>__remoteTranslation</b>(<i>fn, remote2local=True</i>)
-<p>
-        Private method to perform the path translation.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-filename to be translated (string)
-</dd><dt><i>remote2local</i></dt>
-<dd>
-flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-translated filename (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.__sendJsonCommand" ID="DebuggerInterfacePython2.__sendJsonCommand"></a>
-<h4>DebuggerInterfacePython2.__sendJsonCommand</h4>
-<b>__sendJsonCommand</b>(<i>command, params</i>)
-<p>
-        Private method to send a single command to the client.
-</p><dl>
-<dt><i>command</i> (str)</dt>
-<dd>
-command name to be sent
-</dd><dt><i>params</i> (dict)</dt>
-<dd>
-dictionary of named parameters for the command
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.__startProcess" ID="DebuggerInterfacePython2.__startProcess"></a>
-<h4>DebuggerInterfacePython2.__startProcess</h4>
-<b>__startProcess</b>(<i>program, arguments, environment=None</i>)
-<p>
-        Private method to start the debugger client process.
-</p><dl>
-<dt><i>program</i></dt>
-<dd>
-name of the executable to start (string)
-</dd><dt><i>arguments</i></dt>
-<dd>
-arguments to be passed to the program (list of string)
-</dd><dt><i>environment</i></dt>
-<dd>
-dictionary of environment settings to pass
-            (dict of string)
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-the process object (QProcess) or None
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.flush" ID="DebuggerInterfacePython2.flush"></a>
-<h4>DebuggerInterfacePython2.flush</h4>
-<b>flush</b>(<i></i>)
-<p>
-        Public slot to flush the queue.
-</p><a NAME="DebuggerInterfacePython2.getClientCapabilities" ID="DebuggerInterfacePython2.getClientCapabilities"></a>
-<h4>DebuggerInterfacePython2.getClientCapabilities</h4>
-<b>getClientCapabilities</b>(<i></i>)
-<p>
-        Public method to retrieve the debug clients capabilities.
-</p><dl>
-<dt>Returns:</dt>
-<dd>
-debug client capabilities (integer)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.isConnected" ID="DebuggerInterfacePython2.isConnected"></a>
-<h4>DebuggerInterfacePython2.isConnected</h4>
-<b>isConnected</b>(<i></i>)
-<p>
-        Public method to test, if a debug client has connected.
-</p><dl>
-<dt>Returns:</dt>
-<dd>
-flag indicating the connection status (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.newConnection" ID="DebuggerInterfacePython2.newConnection"></a>
-<h4>DebuggerInterfacePython2.newConnection</h4>
-<b>newConnection</b>(<i>sock</i>)
-<p>
-        Public slot to handle a new connection.
-</p><dl>
-<dt><i>sock</i></dt>
-<dd>
-reference to the socket object (QTcpSocket)
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-flag indicating success (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteBanner" ID="DebuggerInterfacePython2.remoteBanner"></a>
-<h4>DebuggerInterfacePython2.remoteBanner</h4>
-<b>remoteBanner</b>(<i></i>)
-<p>
-        Public slot to get the banner info of the remote client.
-</p><a NAME="DebuggerInterfacePython2.remoteBreakpoint" ID="DebuggerInterfacePython2.remoteBreakpoint"></a>
-<h4>DebuggerInterfacePython2.remoteBreakpoint</h4>
-<b>remoteBreakpoint</b>(<i>fn, line, setBreakpoint, cond=None, temp=False</i>)
-<p>
-        Public method to set or clear a breakpoint.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-filename the breakpoint belongs to (string)
-</dd><dt><i>line</i></dt>
-<dd>
-linenumber of the breakpoint (int)
-</dd><dt><i>setBreakpoint</i></dt>
-<dd>
-flag indicating setting or resetting a
-            breakpoint (boolean)
-</dd><dt><i>cond</i></dt>
-<dd>
-condition of the breakpoint (string)
-</dd><dt><i>temp</i></dt>
-<dd>
-flag indicating a temporary breakpoint (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteBreakpointEnable" ID="DebuggerInterfacePython2.remoteBreakpointEnable"></a>
-<h4>DebuggerInterfacePython2.remoteBreakpointEnable</h4>
-<b>remoteBreakpointEnable</b>(<i>fn, line, enable</i>)
-<p>
-        Public method to enable or disable a breakpoint.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-filename the breakpoint belongs to (string)
-</dd><dt><i>line</i></dt>
-<dd>
-linenumber of the breakpoint (int)
-</dd><dt><i>enable</i></dt>
-<dd>
-flag indicating enabling or disabling a breakpoint
-            (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteBreakpointIgnore" ID="DebuggerInterfacePython2.remoteBreakpointIgnore"></a>
-<h4>DebuggerInterfacePython2.remoteBreakpointIgnore</h4>
-<b>remoteBreakpointIgnore</b>(<i>fn, line, count</i>)
-<p>
-        Public method to ignore a breakpoint the next couple of occurrences.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-filename the breakpoint belongs to (string)
-</dd><dt><i>line</i></dt>
-<dd>
-linenumber of the breakpoint (int)
-</dd><dt><i>count</i></dt>
-<dd>
-number of occurrences to ignore (int)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteCapabilities" ID="DebuggerInterfacePython2.remoteCapabilities"></a>
-<h4>DebuggerInterfacePython2.remoteCapabilities</h4>
-<b>remoteCapabilities</b>(<i></i>)
-<p>
-        Public slot to get the debug clients capabilities.
-</p><a NAME="DebuggerInterfacePython2.remoteClientSetFilter" ID="DebuggerInterfacePython2.remoteClientSetFilter"></a>
-<h4>DebuggerInterfacePython2.remoteClientSetFilter</h4>
-<b>remoteClientSetFilter</b>(<i>scope, filterStr</i>)
-<p>
-        Public method to set a variables filter list.
-</p><dl>
-<dt><i>scope</i></dt>
-<dd>
-the scope of the variables (0 = local, 1 = global)
-</dd><dt><i>filterStr</i></dt>
-<dd>
-regexp string for variable names to filter out
-            (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteClientVariable" ID="DebuggerInterfacePython2.remoteClientVariable"></a>
-<h4>DebuggerInterfacePython2.remoteClientVariable</h4>
-<b>remoteClientVariable</b>(<i>scope, filterList, var, framenr=0</i>)
-<p>
-        Public method to request the variables of the debugged program.
-</p><dl>
-<dt><i>scope</i></dt>
-<dd>
-the scope of the variables (0 = local, 1 = global)
-</dd><dt><i>filterList</i></dt>
-<dd>
-list of variable types to filter out (list of int)
-</dd><dt><i>var</i></dt>
-<dd>
-list encoded name of variable to retrieve (string)
-</dd><dt><i>framenr</i></dt>
-<dd>
-framenumber of the variables to retrieve (int)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteClientVariables" ID="DebuggerInterfacePython2.remoteClientVariables"></a>
-<h4>DebuggerInterfacePython2.remoteClientVariables</h4>
-<b>remoteClientVariables</b>(<i>scope, filterList, framenr=0</i>)
-<p>
-        Public method to request the variables of the debugged program.
-</p><dl>
-<dt><i>scope</i></dt>
-<dd>
-the scope of the variables (0 = local, 1 = global)
-</dd><dt><i>filterList</i></dt>
-<dd>
-list of variable types to filter out (list of int)
-</dd><dt><i>framenr</i></dt>
-<dd>
-framenumber of the variables to retrieve (int)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteCompletion" ID="DebuggerInterfacePython2.remoteCompletion"></a>
-<h4>DebuggerInterfacePython2.remoteCompletion</h4>
-<b>remoteCompletion</b>(<i>text</i>)
-<p>
-        Public slot to get the a list of possible commandline completions
-        from the remote client.
-</p><dl>
-<dt><i>text</i></dt>
-<dd>
-the text to be completed (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteContinue" ID="DebuggerInterfacePython2.remoteContinue"></a>
-<h4>DebuggerInterfacePython2.remoteContinue</h4>
-<b>remoteContinue</b>(<i>special=False</i>)
-<p>
-        Public method to continue the debugged program.
-</p><dl>
-<dt><i>special</i></dt>
-<dd>
-flag indicating a special continue operation (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteCoverage" ID="DebuggerInterfacePython2.remoteCoverage"></a>
-<h4>DebuggerInterfacePython2.remoteCoverage</h4>
-<b>remoteCoverage</b>(<i>fn, argv, wd, erase=False</i>)
-<p>
-        Public method to load a new program to collect coverage data.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-the filename to run (string)
-</dd><dt><i>argv</i></dt>
-<dd>
-the commandline arguments to pass to the program (string)
-</dd><dt><i>wd</i></dt>
-<dd>
-the working directory for the program (string)
-</dd><dt><i>erase=</i></dt>
-<dd>
-flag indicating that coverage info should be
-            cleared first (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteEnvironment" ID="DebuggerInterfacePython2.remoteEnvironment"></a>
-<h4>DebuggerInterfacePython2.remoteEnvironment</h4>
-<b>remoteEnvironment</b>(<i>env</i>)
-<p>
-        Public method to set the environment for a program to debug, run, ...
-</p><dl>
-<dt><i>env</i></dt>
-<dd>
-environment settings (dictionary)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteLoad" ID="DebuggerInterfacePython2.remoteLoad"></a>
-<h4>DebuggerInterfacePython2.remoteLoad</h4>
-<b>remoteLoad</b>(<i>fn, argv, wd, traceInterpreter=False, autoContinue=True, autoFork=False, forkChild=False</i>)
-<p>
-        Public method to load a new program to debug.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-the filename to debug (string)
-</dd><dt><i>argv</i></dt>
-<dd>
-the commandline arguments to pass to the program (string)
-</dd><dt><i>wd</i></dt>
-<dd>
-the working directory for the program (string)
-</dd><dt><i>traceInterpreter=</i></dt>
-<dd>
-flag indicating if the interpreter library
-            should be traced as well (boolean)
-</dd><dt><i>autoContinue=</i></dt>
-<dd>
-flag indicating, that the debugger should not
-            stop at the first executable line (boolean)
-</dd><dt><i>autoFork=</i></dt>
-<dd>
-flag indicating the automatic fork mode (boolean)
-</dd><dt><i>forkChild=</i></dt>
-<dd>
-flag indicating to debug the child after forking
-            (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteMoveIP" ID="DebuggerInterfacePython2.remoteMoveIP"></a>
-<h4>DebuggerInterfacePython2.remoteMoveIP</h4>
-<b>remoteMoveIP</b>(<i>line</i>)
-<p>
-        Public method to move the instruction pointer to a different line.
-</p><dl>
-<dt><i>line</i></dt>
-<dd>
-the new line, where execution should be continued
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteProfile" ID="DebuggerInterfacePython2.remoteProfile"></a>
-<h4>DebuggerInterfacePython2.remoteProfile</h4>
-<b>remoteProfile</b>(<i>fn, argv, wd, erase=False</i>)
-<p>
-        Public method to load a new program to collect profiling data.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-the filename to run (string)
-</dd><dt><i>argv</i></dt>
-<dd>
-the commandline arguments to pass to the program (string)
-</dd><dt><i>wd</i></dt>
-<dd>
-the working directory for the program (string)
-</dd><dt><i>erase=</i></dt>
-<dd>
-flag indicating that timing info should be cleared
-            first (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteRawInput" ID="DebuggerInterfacePython2.remoteRawInput"></a>
-<h4>DebuggerInterfacePython2.remoteRawInput</h4>
-<b>remoteRawInput</b>(<i>s</i>)
-<p>
-        Public method to send the raw input to the debugged program.
-</p><dl>
-<dt><i>s</i></dt>
-<dd>
-the raw input (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteRun" ID="DebuggerInterfacePython2.remoteRun"></a>
-<h4>DebuggerInterfacePython2.remoteRun</h4>
-<b>remoteRun</b>(<i>fn, argv, wd, autoFork=False, forkChild=False</i>)
-<p>
-        Public method to load a new program to run.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-the filename to run (string)
-</dd><dt><i>argv</i></dt>
-<dd>
-the commandline arguments to pass to the program (string)
-</dd><dt><i>wd</i></dt>
-<dd>
-the working directory for the program (string)
-</dd><dt><i>autoFork=</i></dt>
-<dd>
-flag indicating the automatic fork mode (boolean)
-</dd><dt><i>forkChild=</i></dt>
-<dd>
-flag indicating to debug the child after forking
-            (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteSetThread" ID="DebuggerInterfacePython2.remoteSetThread"></a>
-<h4>DebuggerInterfacePython2.remoteSetThread</h4>
-<b>remoteSetThread</b>(<i>tid</i>)
-<p>
-        Public method to request to set the given thread as current thread.
-</p><dl>
-<dt><i>tid</i></dt>
-<dd>
-id of the thread (integer)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteStatement" ID="DebuggerInterfacePython2.remoteStatement"></a>
-<h4>DebuggerInterfacePython2.remoteStatement</h4>
-<b>remoteStatement</b>(<i>stmt</i>)
-<p>
-        Public method to execute a Python statement.
-</p><dl>
-<dt><i>stmt</i></dt>
-<dd>
-the Python statement to execute (string). It
-              should not have a trailing newline.
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteStep" ID="DebuggerInterfacePython2.remoteStep"></a>
-<h4>DebuggerInterfacePython2.remoteStep</h4>
-<b>remoteStep</b>(<i></i>)
-<p>
-        Public method to single step the debugged program.
-</p><a NAME="DebuggerInterfacePython2.remoteStepOut" ID="DebuggerInterfacePython2.remoteStepOut"></a>
-<h4>DebuggerInterfacePython2.remoteStepOut</h4>
-<b>remoteStepOut</b>(<i></i>)
-<p>
-        Public method to step out the debugged program.
-</p><a NAME="DebuggerInterfacePython2.remoteStepOver" ID="DebuggerInterfacePython2.remoteStepOver"></a>
-<h4>DebuggerInterfacePython2.remoteStepOver</h4>
-<b>remoteStepOver</b>(<i></i>)
-<p>
-        Public method to step over the debugged program.
-</p><a NAME="DebuggerInterfacePython2.remoteStepQuit" ID="DebuggerInterfacePython2.remoteStepQuit"></a>
-<h4>DebuggerInterfacePython2.remoteStepQuit</h4>
-<b>remoteStepQuit</b>(<i></i>)
-<p>
-        Public method to stop the debugged program.
-</p><a NAME="DebuggerInterfacePython2.remoteThreadList" ID="DebuggerInterfacePython2.remoteThreadList"></a>
-<h4>DebuggerInterfacePython2.remoteThreadList</h4>
-<b>remoteThreadList</b>(<i></i>)
-<p>
-        Public method to request the list of threads from the client.
-</p><a NAME="DebuggerInterfacePython2.remoteUTPrepare" ID="DebuggerInterfacePython2.remoteUTPrepare"></a>
-<h4>DebuggerInterfacePython2.remoteUTPrepare</h4>
-<b>remoteUTPrepare</b>(<i>fn, tn, tfn, failed, cov, covname, coverase</i>)
-<p>
-        Public method to prepare a new unittest run.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-the filename to load (string)
-</dd><dt><i>tn</i></dt>
-<dd>
-the testname to load (string)
-</dd><dt><i>tfn</i></dt>
-<dd>
-the test function name to load tests from (string)
-</dd><dt><i>failed</i></dt>
-<dd>
-list of failed test, if only failed test should be run
-            (list of strings)
-</dd><dt><i>cov</i></dt>
-<dd>
-flag indicating collection of coverage data is requested
-            (boolean)
-</dd><dt><i>covname</i></dt>
-<dd>
-filename to be used to assemble the coverage caches
-            filename (string)
-</dd><dt><i>coverase</i></dt>
-<dd>
-flag indicating erasure of coverage data is requested
-            (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteUTRun" ID="DebuggerInterfacePython2.remoteUTRun"></a>
-<h4>DebuggerInterfacePython2.remoteUTRun</h4>
-<b>remoteUTRun</b>(<i></i>)
-<p>
-        Public method to start a unittest run.
-</p><a NAME="DebuggerInterfacePython2.remoteUTStop" ID="DebuggerInterfacePython2.remoteUTStop"></a>
-<h4>DebuggerInterfacePython2.remoteUTStop</h4>
-<b>remoteUTStop</b>(<i></i>)
-<p>
-        Public method to stop a unittest run.
-</p><a NAME="DebuggerInterfacePython2.remoteWatchpoint" ID="DebuggerInterfacePython2.remoteWatchpoint"></a>
-<h4>DebuggerInterfacePython2.remoteWatchpoint</h4>
-<b>remoteWatchpoint</b>(<i>cond, setWatch, temp=False</i>)
-<p>
-        Public method to set or clear a watch expression.
-</p><dl>
-<dt><i>cond</i></dt>
-<dd>
-expression of the watch expression (string)
-</dd><dt><i>setWatch</i></dt>
-<dd>
-flag indicating setting or resetting a watch expression
-            (boolean)
-</dd><dt><i>temp</i></dt>
-<dd>
-flag indicating a temporary watch expression (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteWatchpointEnable" ID="DebuggerInterfacePython2.remoteWatchpointEnable"></a>
-<h4>DebuggerInterfacePython2.remoteWatchpointEnable</h4>
-<b>remoteWatchpointEnable</b>(<i>cond, enable</i>)
-<p>
-        Public method to enable or disable a watch expression.
-</p><dl>
-<dt><i>cond</i></dt>
-<dd>
-expression of the watch expression (string)
-</dd><dt><i>enable</i></dt>
-<dd>
-flag indicating enabling or disabling a watch expression
-            (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.remoteWatchpointIgnore" ID="DebuggerInterfacePython2.remoteWatchpointIgnore"></a>
-<h4>DebuggerInterfacePython2.remoteWatchpointIgnore</h4>
-<b>remoteWatchpointIgnore</b>(<i>cond, count</i>)
-<p>
-        Public method to ignore a watch expression the next couple of
-        occurrences.
-</p><dl>
-<dt><i>cond</i></dt>
-<dd>
-expression of the watch expression (string)
-</dd><dt><i>count</i></dt>
-<dd>
-number of occurrences to ignore (int)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.setCallTraceEnabled" ID="DebuggerInterfacePython2.setCallTraceEnabled"></a>
-<h4>DebuggerInterfacePython2.setCallTraceEnabled</h4>
-<b>setCallTraceEnabled</b>(<i>on</i>)
-<p>
-        Public method to set the call trace state.
-</p><dl>
-<dt><i>on</i></dt>
-<dd>
-flag indicating to enable the call trace function (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.shutdown" ID="DebuggerInterfacePython2.shutdown"></a>
-<h4>DebuggerInterfacePython2.shutdown</h4>
-<b>shutdown</b>(<i></i>)
-<p>
-        Public method to cleanly shut down.
-</p><p>
-        It closes our socket and shuts down
-        the debug client. (Needed on Win OS)
-</p><a NAME="DebuggerInterfacePython2.startRemote" ID="DebuggerInterfacePython2.startRemote"></a>
-<h4>DebuggerInterfacePython2.startRemote</h4>
-<b>startRemote</b>(<i>port, runInConsole</i>)
-<p>
-        Public method to start a remote Python interpreter.
-</p><dl>
-<dt><i>port</i></dt>
-<dd>
-portnumber the debug server is listening on (integer)
-</dd><dt><i>runInConsole</i></dt>
-<dd>
-flag indicating to start the debugger in a
-            console window (boolean)
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython2.startRemoteForProject" ID="DebuggerInterfacePython2.startRemoteForProject"></a>
-<h4>DebuggerInterfacePython2.startRemoteForProject</h4>
-<b>startRemoteForProject</b>(<i>port, runInConsole</i>)
-<p>
-        Public method to start a remote Python interpreter for a project.
-</p><dl>
-<dt><i>port</i></dt>
-<dd>
-portnumber the debug server is listening on (integer)
-</dd><dt><i>runInConsole</i></dt>
-<dd>
-flag indicating to start the debugger in a
-            console window (boolean)
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-</dd>
-</dl>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="createDebuggerInterfacePython2" ID="createDebuggerInterfacePython2"></a>
-<h2>createDebuggerInterfacePython2</h2>
-<b>createDebuggerInterfacePython2</b>(<i>debugServer, passive</i>)
-<p>
-    Module function to create a debugger interface instance.
-</p><p>
-
-</p><dl>
-<dt><i>debugServer</i> (DebugServer)</dt>
-<dd>
-reference to the debug server
-</dd><dt><i>passive</i> (bool)</dt>
-<dd>
-flag indicating passive connection mode
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-instantiated debugger interface
-</dd>
-</dl><dl>
-<dt>Return Type:</dt>
-<dd>
-DebuggerInterfacePython
-</dd>
-</dl>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="getRegistryData" ID="getRegistryData"></a>
-<h2>getRegistryData</h2>
-<b>getRegistryData</b>(<i></i>)
-<p>
-    Module function to get characterizing data for the debugger interface.
-</p><dl>
-<dt>Returns:</dt>
-<dd>
-tuple containing  client type, client capabilities, client file
-        type associations and reference to creation function
-</dd>
-</dl><dl>
-<dt>Return Type:</dt>
-<dd>
-tuple of (str, int, list of str, function)
-</dd>
-</dl>
-<div align="right"><a href="#top">Up</a></div>
-<hr />
-</body></html>
\ No newline at end of file
--- a/Documentation/Source/eric6.Debugger.DebuggerInterfacePython3.html	Sat Aug 26 17:10:43 2017 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,860 +0,0 @@
-<!DOCTYPE html>
-<html><head>
-<title>eric6.Debugger.DebuggerInterfacePython3</title>
-<meta charset="UTF-8">
-<style>
-body {
-    background: #EDECE6;
-    margin: 0em 1em 10em 1em;
-    color: black;
-}
-
-h1 { color: white; background: #85774A; }
-h2 { color: white; background: #85774A; }
-h3 { color: white; background: #9D936E; }
-h4 { color: white; background: #9D936E; }
-    
-a { color: #BA6D36; }
-
-</style>
-</head>
-<body><a NAME="top" ID="top"></a>
-<h1>eric6.Debugger.DebuggerInterfacePython3</h1>
-<p>
-Module implementing the Python3 debugger interface for the debug server.
-</p>
-<h3>Global Attributes</h3>
-<table>
-<tr><td>ClientDefaultCapabilities</td></tr>
-</table>
-<h3>Classes</h3>
-<table>
-<tr>
-<td><a href="#DebuggerInterfacePython3">DebuggerInterfacePython3</a></td>
-<td>Class implementing the Python 3 debugger interface for the debug server.</td>
-</tr>
-</table>
-<h3>Functions</h3>
-<table>
-<tr>
-<td><a href="#createDebuggerInterfacePython3">createDebuggerInterfacePython3</a></td>
-<td>Module function to create a debugger interface instance.</td>
-</tr><tr>
-<td><a href="#getRegistryData">getRegistryData</a></td>
-<td>Module function to get characterizing data for the debugger interface.</td>
-</tr>
-</table>
-<hr /><hr />
-<a NAME="DebuggerInterfacePython3" ID="DebuggerInterfacePython3"></a>
-<h2>DebuggerInterfacePython3</h2>
-<p>
-    Class implementing the Python 3 debugger interface for the debug server.
-</p>
-<h3>Derived from</h3>
-QObject
-<h3>Class Attributes</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Class Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<h3>Methods</h3>
-<table>
-<tr>
-<td><a href="#DebuggerInterfacePython3.__init__">DebuggerInterfacePython3</a></td>
-<td>Constructor</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.__askForkTo">__askForkTo</a></td>
-<td>Private method to ask the user which branch of a fork to follow.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.__handleJsonCommand">__handleJsonCommand</a></td>
-<td>Private method to handle a command or response serialized as a JSON string.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.__identityTranslation">__identityTranslation</a></td>
-<td>Private method to perform the identity path translation.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.__parseClientLine">__parseClientLine</a></td>
-<td>Private method to handle data from the client.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.__remoteTranslation">__remoteTranslation</a></td>
-<td>Private method to perform the path translation.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.__sendJsonCommand">__sendJsonCommand</a></td>
-<td>Private method to send a single command to the client.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.__startProcess">__startProcess</a></td>
-<td>Private method to start the debugger client process.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.flush">flush</a></td>
-<td>Public slot to flush the queue.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.getClientCapabilities">getClientCapabilities</a></td>
-<td>Public method to retrieve the debug clients capabilities.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.isConnected">isConnected</a></td>
-<td>Public method to test, if a debug client has connected.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.newConnection">newConnection</a></td>
-<td>Public slot to handle a new connection.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteBanner">remoteBanner</a></td>
-<td>Public slot to get the banner info of the remote client.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteBreakpoint">remoteBreakpoint</a></td>
-<td>Public method to set or clear a breakpoint.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteBreakpointEnable">remoteBreakpointEnable</a></td>
-<td>Public method to enable or disable a breakpoint.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteBreakpointIgnore">remoteBreakpointIgnore</a></td>
-<td>Public method to ignore a breakpoint the next couple of occurrences.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteCapabilities">remoteCapabilities</a></td>
-<td>Public slot to get the debug clients capabilities.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteClientSetFilter">remoteClientSetFilter</a></td>
-<td>Public method to set a variables filter list.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteClientVariable">remoteClientVariable</a></td>
-<td>Public method to request the variables of the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteClientVariables">remoteClientVariables</a></td>
-<td>Public method to request the variables of the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteCompletion">remoteCompletion</a></td>
-<td>Public slot to get the a list of possible commandline completions from the remote client.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteContinue">remoteContinue</a></td>
-<td>Public method to continue the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteCoverage">remoteCoverage</a></td>
-<td>Public method to load a new program to collect coverage data.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteEnvironment">remoteEnvironment</a></td>
-<td>Public method to set the environment for a program to debug, run, ...</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteLoad">remoteLoad</a></td>
-<td>Public method to load a new program to debug.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteMoveIP">remoteMoveIP</a></td>
-<td>Public method to move the instruction pointer to a different line.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteProfile">remoteProfile</a></td>
-<td>Public method to load a new program to collect profiling data.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteRawInput">remoteRawInput</a></td>
-<td>Public method to send the raw input to the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteRun">remoteRun</a></td>
-<td>Public method to load a new program to run.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteSetThread">remoteSetThread</a></td>
-<td>Public method to request to set the given thread as current thread.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteStatement">remoteStatement</a></td>
-<td>Public method to execute a Python statement.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteStep">remoteStep</a></td>
-<td>Public method to single step the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteStepOut">remoteStepOut</a></td>
-<td>Public method to step out the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteStepOver">remoteStepOver</a></td>
-<td>Public method to step over the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteStepQuit">remoteStepQuit</a></td>
-<td>Public method to stop the debugged program.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteThreadList">remoteThreadList</a></td>
-<td>Public method to request the list of threads from the client.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteUTPrepare">remoteUTPrepare</a></td>
-<td>Public method to prepare a new unittest run.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteUTRun">remoteUTRun</a></td>
-<td>Public method to start a unittest run.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteUTStop">remoteUTStop</a></td>
-<td>Public method to stop a unittest run.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteWatchpoint">remoteWatchpoint</a></td>
-<td>Public method to set or clear a watch expression.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteWatchpointEnable">remoteWatchpointEnable</a></td>
-<td>Public method to enable or disable a watch expression.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.remoteWatchpointIgnore">remoteWatchpointIgnore</a></td>
-<td>Public method to ignore a watch expression the next couple of occurrences.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.setCallTraceEnabled">setCallTraceEnabled</a></td>
-<td>Public method to set the call trace state.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.shutdown">shutdown</a></td>
-<td>Public method to cleanly shut down.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.startRemote">startRemote</a></td>
-<td>Public method to start a remote Python interpreter.</td>
-</tr><tr>
-<td><a href="#DebuggerInterfacePython3.startRemoteForProject">startRemoteForProject</a></td>
-<td>Public method to start a remote Python interpreter for a project.</td>
-</tr>
-</table>
-<h3>Static Methods</h3>
-<table>
-<tr><td>None</td></tr>
-</table>
-<a NAME="DebuggerInterfacePython3.__init__" ID="DebuggerInterfacePython3.__init__"></a>
-<h4>DebuggerInterfacePython3 (Constructor)</h4>
-<b>DebuggerInterfacePython3</b>(<i>debugServer, passive</i>)
-<p>
-        Constructor
-</p><dl>
-<dt><i>debugServer</i></dt>
-<dd>
-reference to the debug server (DebugServer)
-</dd><dt><i>passive</i></dt>
-<dd>
-flag indicating passive connection mode (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.__askForkTo" ID="DebuggerInterfacePython3.__askForkTo"></a>
-<h4>DebuggerInterfacePython3.__askForkTo</h4>
-<b>__askForkTo</b>(<i></i>)
-<p>
-        Private method to ask the user which branch of a fork to follow.
-</p><a NAME="DebuggerInterfacePython3.__handleJsonCommand" ID="DebuggerInterfacePython3.__handleJsonCommand"></a>
-<h4>DebuggerInterfacePython3.__handleJsonCommand</h4>
-<b>__handleJsonCommand</b>(<i>jsonStr</i>)
-<p>
-        Private method to handle a command or response serialized as a
-        JSON string.
-</p><dl>
-<dt><i>jsonStr</i> (str)</dt>
-<dd>
-string containing the command or response received
-            from the debug backend
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.__identityTranslation" ID="DebuggerInterfacePython3.__identityTranslation"></a>
-<h4>DebuggerInterfacePython3.__identityTranslation</h4>
-<b>__identityTranslation</b>(<i>fn, remote2local=True</i>)
-<p>
-        Private method to perform the identity path translation.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-filename to be translated (string)
-</dd><dt><i>remote2local</i></dt>
-<dd>
-flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-translated filename (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.__parseClientLine" ID="DebuggerInterfacePython3.__parseClientLine"></a>
-<h4>DebuggerInterfacePython3.__parseClientLine</h4>
-<b>__parseClientLine</b>(<i></i>)
-<p>
-        Private method to handle data from the client.
-</p><a NAME="DebuggerInterfacePython3.__remoteTranslation" ID="DebuggerInterfacePython3.__remoteTranslation"></a>
-<h4>DebuggerInterfacePython3.__remoteTranslation</h4>
-<b>__remoteTranslation</b>(<i>fn, remote2local=True</i>)
-<p>
-        Private method to perform the path translation.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-filename to be translated (string)
-</dd><dt><i>remote2local</i></dt>
-<dd>
-flag indicating the direction of translation
-            (False = local to remote, True = remote to local [default])
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-translated filename (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.__sendJsonCommand" ID="DebuggerInterfacePython3.__sendJsonCommand"></a>
-<h4>DebuggerInterfacePython3.__sendJsonCommand</h4>
-<b>__sendJsonCommand</b>(<i>command, params</i>)
-<p>
-        Private method to send a single command to the client.
-</p><dl>
-<dt><i>command</i> (str)</dt>
-<dd>
-command name to be sent
-</dd><dt><i>params</i> (dict)</dt>
-<dd>
-dictionary of named parameters for the command
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.__startProcess" ID="DebuggerInterfacePython3.__startProcess"></a>
-<h4>DebuggerInterfacePython3.__startProcess</h4>
-<b>__startProcess</b>(<i>program, arguments, environment=None</i>)
-<p>
-        Private method to start the debugger client process.
-</p><dl>
-<dt><i>program</i></dt>
-<dd>
-name of the executable to start (string)
-</dd><dt><i>arguments</i></dt>
-<dd>
-arguments to be passed to the program (list of string)
-</dd><dt><i>environment</i></dt>
-<dd>
-dictionary of environment settings to pass
-            (dict of string)
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-the process object (QProcess) or None
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.flush" ID="DebuggerInterfacePython3.flush"></a>
-<h4>DebuggerInterfacePython3.flush</h4>
-<b>flush</b>(<i></i>)
-<p>
-        Public slot to flush the queue.
-</p><a NAME="DebuggerInterfacePython3.getClientCapabilities" ID="DebuggerInterfacePython3.getClientCapabilities"></a>
-<h4>DebuggerInterfacePython3.getClientCapabilities</h4>
-<b>getClientCapabilities</b>(<i></i>)
-<p>
-        Public method to retrieve the debug clients capabilities.
-</p><dl>
-<dt>Returns:</dt>
-<dd>
-debug client capabilities (integer)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.isConnected" ID="DebuggerInterfacePython3.isConnected"></a>
-<h4>DebuggerInterfacePython3.isConnected</h4>
-<b>isConnected</b>(<i></i>)
-<p>
-        Public method to test, if a debug client has connected.
-</p><dl>
-<dt>Returns:</dt>
-<dd>
-flag indicating the connection status (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.newConnection" ID="DebuggerInterfacePython3.newConnection"></a>
-<h4>DebuggerInterfacePython3.newConnection</h4>
-<b>newConnection</b>(<i>sock</i>)
-<p>
-        Public slot to handle a new connection.
-</p><dl>
-<dt><i>sock</i></dt>
-<dd>
-reference to the socket object (QTcpSocket)
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-flag indicating success (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteBanner" ID="DebuggerInterfacePython3.remoteBanner"></a>
-<h4>DebuggerInterfacePython3.remoteBanner</h4>
-<b>remoteBanner</b>(<i></i>)
-<p>
-        Public slot to get the banner info of the remote client.
-</p><a NAME="DebuggerInterfacePython3.remoteBreakpoint" ID="DebuggerInterfacePython3.remoteBreakpoint"></a>
-<h4>DebuggerInterfacePython3.remoteBreakpoint</h4>
-<b>remoteBreakpoint</b>(<i>fn, line, setBreakpoint, cond=None, temp=False</i>)
-<p>
-        Public method to set or clear a breakpoint.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-filename the breakpoint belongs to (string)
-</dd><dt><i>line</i></dt>
-<dd>
-linenumber of the breakpoint (int)
-</dd><dt><i>setBreakpoint</i></dt>
-<dd>
-flag indicating setting or resetting a
-            breakpoint (boolean)
-</dd><dt><i>cond</i></dt>
-<dd>
-condition of the breakpoint (string)
-</dd><dt><i>temp</i></dt>
-<dd>
-flag indicating a temporary breakpoint (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteBreakpointEnable" ID="DebuggerInterfacePython3.remoteBreakpointEnable"></a>
-<h4>DebuggerInterfacePython3.remoteBreakpointEnable</h4>
-<b>remoteBreakpointEnable</b>(<i>fn, line, enable</i>)
-<p>
-        Public method to enable or disable a breakpoint.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-filename the breakpoint belongs to (string)
-</dd><dt><i>line</i></dt>
-<dd>
-linenumber of the breakpoint (int)
-</dd><dt><i>enable</i></dt>
-<dd>
-flag indicating enabling or disabling a breakpoint
-            (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteBreakpointIgnore" ID="DebuggerInterfacePython3.remoteBreakpointIgnore"></a>
-<h4>DebuggerInterfacePython3.remoteBreakpointIgnore</h4>
-<b>remoteBreakpointIgnore</b>(<i>fn, line, count</i>)
-<p>
-        Public method to ignore a breakpoint the next couple of occurrences.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-filename the breakpoint belongs to (string)
-</dd><dt><i>line</i></dt>
-<dd>
-linenumber of the breakpoint (int)
-</dd><dt><i>count</i></dt>
-<dd>
-number of occurrences to ignore (int)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteCapabilities" ID="DebuggerInterfacePython3.remoteCapabilities"></a>
-<h4>DebuggerInterfacePython3.remoteCapabilities</h4>
-<b>remoteCapabilities</b>(<i></i>)
-<p>
-        Public slot to get the debug clients capabilities.
-</p><a NAME="DebuggerInterfacePython3.remoteClientSetFilter" ID="DebuggerInterfacePython3.remoteClientSetFilter"></a>
-<h4>DebuggerInterfacePython3.remoteClientSetFilter</h4>
-<b>remoteClientSetFilter</b>(<i>scope, filterStr</i>)
-<p>
-        Public method to set a variables filter list.
-</p><dl>
-<dt><i>scope</i></dt>
-<dd>
-the scope of the variables (0 = local, 1 = global)
-</dd><dt><i>filterStr</i></dt>
-<dd>
-regexp string for variable names to filter out
-            (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteClientVariable" ID="DebuggerInterfacePython3.remoteClientVariable"></a>
-<h4>DebuggerInterfacePython3.remoteClientVariable</h4>
-<b>remoteClientVariable</b>(<i>scope, filterList, var, framenr=0</i>)
-<p>
-        Public method to request the variables of the debugged program.
-</p><dl>
-<dt><i>scope</i></dt>
-<dd>
-the scope of the variables (0 = local, 1 = global)
-</dd><dt><i>filterList</i></dt>
-<dd>
-list of variable types to filter out (list of int)
-</dd><dt><i>var</i></dt>
-<dd>
-list encoded name of variable to retrieve (string)
-</dd><dt><i>framenr</i></dt>
-<dd>
-framenumber of the variables to retrieve (int)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteClientVariables" ID="DebuggerInterfacePython3.remoteClientVariables"></a>
-<h4>DebuggerInterfacePython3.remoteClientVariables</h4>
-<b>remoteClientVariables</b>(<i>scope, filterList, framenr=0</i>)
-<p>
-        Public method to request the variables of the debugged program.
-</p><dl>
-<dt><i>scope</i></dt>
-<dd>
-the scope of the variables (0 = local, 1 = global)
-</dd><dt><i>filterList</i></dt>
-<dd>
-list of variable types to filter out (list of int)
-</dd><dt><i>framenr</i></dt>
-<dd>
-framenumber of the variables to retrieve (int)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteCompletion" ID="DebuggerInterfacePython3.remoteCompletion"></a>
-<h4>DebuggerInterfacePython3.remoteCompletion</h4>
-<b>remoteCompletion</b>(<i>text</i>)
-<p>
-        Public slot to get the a list of possible commandline completions
-        from the remote client.
-</p><dl>
-<dt><i>text</i></dt>
-<dd>
-the text to be completed (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteContinue" ID="DebuggerInterfacePython3.remoteContinue"></a>
-<h4>DebuggerInterfacePython3.remoteContinue</h4>
-<b>remoteContinue</b>(<i>special=False</i>)
-<p>
-        Public method to continue the debugged program.
-</p><dl>
-<dt><i>special</i></dt>
-<dd>
-flag indicating a special continue operation
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteCoverage" ID="DebuggerInterfacePython3.remoteCoverage"></a>
-<h4>DebuggerInterfacePython3.remoteCoverage</h4>
-<b>remoteCoverage</b>(<i>fn, argv, wd, erase=False</i>)
-<p>
-        Public method to load a new program to collect coverage data.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-the filename to run (string)
-</dd><dt><i>argv</i></dt>
-<dd>
-the commandline arguments to pass to the program (string)
-</dd><dt><i>wd</i></dt>
-<dd>
-the working directory for the program (string)
-</dd><dt><i>erase=</i></dt>
-<dd>
-flag indicating that coverage info should be
-            cleared first (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteEnvironment" ID="DebuggerInterfacePython3.remoteEnvironment"></a>
-<h4>DebuggerInterfacePython3.remoteEnvironment</h4>
-<b>remoteEnvironment</b>(<i>env</i>)
-<p>
-        Public method to set the environment for a program to debug, run, ...
-</p><dl>
-<dt><i>env</i></dt>
-<dd>
-environment settings (dictionary)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteLoad" ID="DebuggerInterfacePython3.remoteLoad"></a>
-<h4>DebuggerInterfacePython3.remoteLoad</h4>
-<b>remoteLoad</b>(<i>fn, argv, wd, traceInterpreter=False, autoContinue=True, autoFork=False, forkChild=False</i>)
-<p>
-        Public method to load a new program to debug.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-the filename to debug (string)
-</dd><dt><i>argv</i></dt>
-<dd>
-the commandline arguments to pass to the program (string)
-</dd><dt><i>wd</i></dt>
-<dd>
-the working directory for the program (string)
-</dd><dt><i>traceInterpreter=</i></dt>
-<dd>
-flag indicating if the interpreter library
-            should be traced as well (boolean)
-</dd><dt><i>autoContinue=</i></dt>
-<dd>
-flag indicating, that the debugger should not
-            stop at the first executable line (boolean)
-</dd><dt><i>autoFork=</i></dt>
-<dd>
-flag indicating the automatic fork mode (boolean)
-</dd><dt><i>forkChild=</i></dt>
-<dd>
-flag indicating to debug the child after forking
-            (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteMoveIP" ID="DebuggerInterfacePython3.remoteMoveIP"></a>
-<h4>DebuggerInterfacePython3.remoteMoveIP</h4>
-<b>remoteMoveIP</b>(<i>line</i>)
-<p>
-        Public method to move the instruction pointer to a different line.
-</p><dl>
-<dt><i>line</i></dt>
-<dd>
-the new line, where execution should be continued
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteProfile" ID="DebuggerInterfacePython3.remoteProfile"></a>
-<h4>DebuggerInterfacePython3.remoteProfile</h4>
-<b>remoteProfile</b>(<i>fn, argv, wd, erase=False</i>)
-<p>
-        Public method to load a new program to collect profiling data.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-the filename to run (string)
-</dd><dt><i>argv</i></dt>
-<dd>
-the commandline arguments to pass to the program (string)
-</dd><dt><i>wd</i></dt>
-<dd>
-the working directory for the program (string)
-</dd><dt><i>erase=</i></dt>
-<dd>
-flag indicating that timing info should be cleared
-            first (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteRawInput" ID="DebuggerInterfacePython3.remoteRawInput"></a>
-<h4>DebuggerInterfacePython3.remoteRawInput</h4>
-<b>remoteRawInput</b>(<i>s</i>)
-<p>
-        Public method to send the raw input to the debugged program.
-</p><dl>
-<dt><i>s</i></dt>
-<dd>
-the raw input (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteRun" ID="DebuggerInterfacePython3.remoteRun"></a>
-<h4>DebuggerInterfacePython3.remoteRun</h4>
-<b>remoteRun</b>(<i>fn, argv, wd, autoFork=False, forkChild=False</i>)
-<p>
-        Public method to load a new program to run.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-the filename to run (string)
-</dd><dt><i>argv</i></dt>
-<dd>
-the commandline arguments to pass to the program (string)
-</dd><dt><i>wd</i></dt>
-<dd>
-the working directory for the program (string)
-</dd><dt><i>autoFork=</i></dt>
-<dd>
-flag indicating the automatic fork mode (boolean)
-</dd><dt><i>forkChild=</i></dt>
-<dd>
-flag indicating to debug the child after forking
-            (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteSetThread" ID="DebuggerInterfacePython3.remoteSetThread"></a>
-<h4>DebuggerInterfacePython3.remoteSetThread</h4>
-<b>remoteSetThread</b>(<i>tid</i>)
-<p>
-        Public method to request to set the given thread as current thread.
-</p><dl>
-<dt><i>tid</i></dt>
-<dd>
-id of the thread (integer)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteStatement" ID="DebuggerInterfacePython3.remoteStatement"></a>
-<h4>DebuggerInterfacePython3.remoteStatement</h4>
-<b>remoteStatement</b>(<i>stmt</i>)
-<p>
-        Public method to execute a Python statement.
-</p><dl>
-<dt><i>stmt</i></dt>
-<dd>
-the Python statement to execute (string). It
-              should not have a trailing newline.
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteStep" ID="DebuggerInterfacePython3.remoteStep"></a>
-<h4>DebuggerInterfacePython3.remoteStep</h4>
-<b>remoteStep</b>(<i></i>)
-<p>
-        Public method to single step the debugged program.
-</p><a NAME="DebuggerInterfacePython3.remoteStepOut" ID="DebuggerInterfacePython3.remoteStepOut"></a>
-<h4>DebuggerInterfacePython3.remoteStepOut</h4>
-<b>remoteStepOut</b>(<i></i>)
-<p>
-        Public method to step out the debugged program.
-</p><a NAME="DebuggerInterfacePython3.remoteStepOver" ID="DebuggerInterfacePython3.remoteStepOver"></a>
-<h4>DebuggerInterfacePython3.remoteStepOver</h4>
-<b>remoteStepOver</b>(<i></i>)
-<p>
-        Public method to step over the debugged program.
-</p><a NAME="DebuggerInterfacePython3.remoteStepQuit" ID="DebuggerInterfacePython3.remoteStepQuit"></a>
-<h4>DebuggerInterfacePython3.remoteStepQuit</h4>
-<b>remoteStepQuit</b>(<i></i>)
-<p>
-        Public method to stop the debugged program.
-</p><a NAME="DebuggerInterfacePython3.remoteThreadList" ID="DebuggerInterfacePython3.remoteThreadList"></a>
-<h4>DebuggerInterfacePython3.remoteThreadList</h4>
-<b>remoteThreadList</b>(<i></i>)
-<p>
-        Public method to request the list of threads from the client.
-</p><a NAME="DebuggerInterfacePython3.remoteUTPrepare" ID="DebuggerInterfacePython3.remoteUTPrepare"></a>
-<h4>DebuggerInterfacePython3.remoteUTPrepare</h4>
-<b>remoteUTPrepare</b>(<i>fn, tn, tfn, failed, cov, covname, coverase</i>)
-<p>
-        Public method to prepare a new unittest run.
-</p><dl>
-<dt><i>fn</i></dt>
-<dd>
-the filename to load (string)
-</dd><dt><i>tn</i></dt>
-<dd>
-the testname to load (string)
-</dd><dt><i>tfn</i></dt>
-<dd>
-the test function name to load tests from (string)
-</dd><dt><i>failed</i></dt>
-<dd>
-list of failed test, if only failed test should be run
-            (list of strings)
-</dd><dt><i>cov</i></dt>
-<dd>
-flag indicating collection of coverage data is requested
-            (boolean)
-</dd><dt><i>covname</i></dt>
-<dd>
-filename to be used to assemble the coverage caches
-            filename (string)
-</dd><dt><i>coverase</i></dt>
-<dd>
-flag indicating erasure of coverage data is requested
-            (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteUTRun" ID="DebuggerInterfacePython3.remoteUTRun"></a>
-<h4>DebuggerInterfacePython3.remoteUTRun</h4>
-<b>remoteUTRun</b>(<i></i>)
-<p>
-        Public method to start a unittest run.
-</p><a NAME="DebuggerInterfacePython3.remoteUTStop" ID="DebuggerInterfacePython3.remoteUTStop"></a>
-<h4>DebuggerInterfacePython3.remoteUTStop</h4>
-<b>remoteUTStop</b>(<i></i>)
-<p>
-        Public method to stop a unittest run.
-</p><a NAME="DebuggerInterfacePython3.remoteWatchpoint" ID="DebuggerInterfacePython3.remoteWatchpoint"></a>
-<h4>DebuggerInterfacePython3.remoteWatchpoint</h4>
-<b>remoteWatchpoint</b>(<i>cond, setWatch, temp=False</i>)
-<p>
-        Public method to set or clear a watch expression.
-</p><dl>
-<dt><i>cond</i></dt>
-<dd>
-expression of the watch expression (string)
-</dd><dt><i>setWatch</i></dt>
-<dd>
-flag indicating setting or resetting a watch expression
-            (boolean)
-</dd><dt><i>temp</i></dt>
-<dd>
-flag indicating a temporary watch expression (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteWatchpointEnable" ID="DebuggerInterfacePython3.remoteWatchpointEnable"></a>
-<h4>DebuggerInterfacePython3.remoteWatchpointEnable</h4>
-<b>remoteWatchpointEnable</b>(<i>cond, enable</i>)
-<p>
-        Public method to enable or disable a watch expression.
-</p><dl>
-<dt><i>cond</i></dt>
-<dd>
-expression of the watch expression (string)
-</dd><dt><i>enable</i></dt>
-<dd>
-flag indicating enabling or disabling a watch expression
-            (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.remoteWatchpointIgnore" ID="DebuggerInterfacePython3.remoteWatchpointIgnore"></a>
-<h4>DebuggerInterfacePython3.remoteWatchpointIgnore</h4>
-<b>remoteWatchpointIgnore</b>(<i>cond, count</i>)
-<p>
-        Public method to ignore a watch expression the next couple of
-        occurrences.
-</p><dl>
-<dt><i>cond</i></dt>
-<dd>
-expression of the watch expression (string)
-</dd><dt><i>count</i></dt>
-<dd>
-number of occurrences to ignore (int)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.setCallTraceEnabled" ID="DebuggerInterfacePython3.setCallTraceEnabled"></a>
-<h4>DebuggerInterfacePython3.setCallTraceEnabled</h4>
-<b>setCallTraceEnabled</b>(<i>on</i>)
-<p>
-        Public method to set the call trace state.
-</p><dl>
-<dt><i>on</i></dt>
-<dd>
-flag indicating to enable the call trace function (boolean)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.shutdown" ID="DebuggerInterfacePython3.shutdown"></a>
-<h4>DebuggerInterfacePython3.shutdown</h4>
-<b>shutdown</b>(<i></i>)
-<p>
-        Public method to cleanly shut down.
-</p><p>
-        It closes our socket and shuts down
-        the debug client. (Needed on Win OS)
-</p><a NAME="DebuggerInterfacePython3.startRemote" ID="DebuggerInterfacePython3.startRemote"></a>
-<h4>DebuggerInterfacePython3.startRemote</h4>
-<b>startRemote</b>(<i>port, runInConsole</i>)
-<p>
-        Public method to start a remote Python interpreter.
-</p><dl>
-<dt><i>port</i></dt>
-<dd>
-portnumber the debug server is listening on (integer)
-</dd><dt><i>runInConsole</i></dt>
-<dd>
-flag indicating to start the debugger in a
-            console window (boolean)
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-</dd>
-</dl><a NAME="DebuggerInterfacePython3.startRemoteForProject" ID="DebuggerInterfacePython3.startRemoteForProject"></a>
-<h4>DebuggerInterfacePython3.startRemoteForProject</h4>
-<b>startRemoteForProject</b>(<i>port, runInConsole</i>)
-<p>
-        Public method to start a remote Python interpreter for a project.
-</p><dl>
-<dt><i>port</i></dt>
-<dd>
-portnumber the debug server is listening on (integer)
-</dd><dt><i>runInConsole</i></dt>
-<dd>
-flag indicating to start the debugger in a
-            console window (boolean)
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-client process object (QProcess), a flag to indicate
-            a network connection (boolean) and the name of the interpreter
-            in case of a local execution (string)
-</dd>
-</dl>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="createDebuggerInterfacePython3" ID="createDebuggerInterfacePython3"></a>
-<h2>createDebuggerInterfacePython3</h2>
-<b>createDebuggerInterfacePython3</b>(<i>debugServer, passive</i>)
-<p>
-    Module function to create a debugger interface instance.
-</p><p>
-
-</p><dl>
-<dt><i>debugServer</i> (DebugServer)</dt>
-<dd>
-reference to the debug server
-</dd><dt><i>passive</i> (bool)</dt>
-<dd>
-flag indicating passive connection mode
-</dd>
-</dl><dl>
-<dt>Returns:</dt>
-<dd>
-instantiated debugger interface
-</dd>
-</dl><dl>
-<dt>Return Type:</dt>
-<dd>
-DebuggerInterfacePython
-</dd>
-</dl>
-<div align="right"><a href="#top">Up</a></div>
-<hr /><hr />
-<a NAME="getRegistryData" ID="getRegistryData"></a>
-<h2>getRegistryData</h2>
-<b>getRegistryData</b>(<i></i>)
-<p>
-    Module function to get characterizing data for the debugger interface.
-</p><dl>
-<dt>Returns:</dt>
-<dd>
-tuple containing  client type, client capabilities, client file
-        type associations and reference to creation function
-</dd>
-</dl><dl>
-<dt>Return Type:</dt>
-<dd>
-tuple of (str, int, list of str, function)
-</dd>
-</dl>
-<div align="right"><a href="#top">Up</a></div>
-<hr />
-</body></html>
\ No newline at end of file
--- a/Documentation/Source/index-eric6.Debugger.html	Sat Aug 26 17:10:43 2017 +0200
+++ b/Documentation/Source/index-eric6.Debugger.html	Sat Aug 26 19:26:07 2017 +0200
@@ -61,11 +61,11 @@
 <td><a href="eric6.Debugger.DebuggerInterfaceNone.html">DebuggerInterfaceNone</a></td>
 <td>Module implementing a dummy debugger interface for the debug server.</td>
 </tr><tr>
-<td><a href="eric6.Debugger.DebuggerInterfacePython2.html">DebuggerInterfacePython2</a></td>
-<td>Module implementing the Python debugger interface for the debug server.</td>
+<td><a href="eric6.Debugger.DebuggerInterfacePython.html">DebuggerInterfacePython</a></td>
+<td>Module implementing the Python3 debugger interface for the debug server.</td>
 </tr><tr>
-<td><a href="eric6.Debugger.DebuggerInterfacePython3.html">DebuggerInterfacePython3</a></td>
-<td>Module implementing the Python3 debugger interface for the debug server.</td>
+<td><a href="eric6.Debugger.DebuggerInterfacePython2.html">DebuggerInterfacePython2</a></td>
+<td></td>
 </tr><tr>
 <td><a href="eric6.Debugger.EditBreakpointDialog.html">EditBreakpointDialog</a></td>
 <td>Module implementing a dialog to edit breakpoint properties.</td>
--- a/changelog	Sat Aug 26 17:10:43 2017 +0200
+++ b/changelog	Sat Aug 26 19:26:07 2017 +0200
@@ -2,6 +2,8 @@
 ----------
 Version 17.09:
 - bug fixes
+- Debugger
+  -- unified the Python2 and Python3 debugger interfaces
 - Exporter
   -- extended the HTML exporter to convert Markdown and ReST files to HTML
 - Previewers
--- a/eric6.e4p	Sat Aug 26 17:10:43 2017 +0200
+++ b/eric6.e4p	Sat Aug 26 19:26:07 2017 +0200
@@ -85,8 +85,7 @@
     <Source>Debugger/DebugUI.py</Source>
     <Source>Debugger/DebugViewer.py</Source>
     <Source>Debugger/DebuggerInterfaceNone.py</Source>
-    <Source>Debugger/DebuggerInterfacePython2.py</Source>
-    <Source>Debugger/DebuggerInterfacePython3.py</Source>
+    <Source>Debugger/DebuggerInterfacePython.py</Source>
     <Source>Debugger/EditBreakpointDialog.py</Source>
     <Source>Debugger/EditWatchpointDialog.py</Source>
     <Source>Debugger/ExceptionLogger.py</Source>
--- a/i18n/eric6_cs.ts	Sat Aug 26 17:10:43 2017 +0200
+++ b/i18n/eric6_cs.ts	Sat Aug 26 19:26:07 2017 +0200
@@ -5478,24 +5478,24 @@
 <context>
     <name>DebugServer</name>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="177"/>
+        <location filename="../Debugger/DebugServer.py" line="179"/>
         <source>created</source>
         <comment>must be same as in EditWatchpointDialog</comment>
         <translation>vytvořeno</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="179"/>
+        <location filename="../Debugger/DebugServer.py" line="181"/>
         <source>changed</source>
         <comment>must be same as in EditWatchpointDialog</comment>
         <translation>změněno</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="733"/>
+        <location filename="../Debugger/DebugServer.py" line="744"/>
         <source>Connection from illegal host</source>
         <translation>Spojení z ilegálního hosta</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="1353"/>
+        <location filename="../Debugger/DebugServer.py" line="1364"/>
         <source>
 Not connected
 </source>
@@ -5504,29 +5504,29 @@
 </translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="733"/>
+        <location filename="../Debugger/DebugServer.py" line="744"/>
         <source>&lt;p&gt;A connection was attempted by the illegal host &lt;b&gt;{0}&lt;/b&gt;. Accept this connection?&lt;/p&gt;</source>
         <translation>&lt;p&gt;Pokus o spojení z ilegálního hosta &lt;b&gt;{0}&lt;/b&gt;. Přijmout toto spojení?&lt;/p&gt;</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="1533"/>
+        <location filename="../Debugger/DebugServer.py" line="1544"/>
         <source>Passive debug connection received
 </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="1547"/>
+        <location filename="../Debugger/DebugServer.py" line="1558"/>
         <source>Passive debug connection closed
 </source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="321"/>
+        <location filename="../Debugger/DebugServer.py" line="323"/>
         <source>Register Debugger Interface</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="321"/>
+        <location filename="../Debugger/DebugServer.py" line="323"/>
         <source>&lt;p&gt;The debugger interface &lt;b&gt;{0}&lt;/b&gt; has already been registered. Ignoring this request.&lt;/p&gt;</source>
         <translation type="unfinished"></translation>
     </message>
@@ -6689,82 +6689,92 @@
 <context>
     <name>DebuggerInterfacePython</name>
     <message>
-        <location filename="../Debugger/DebuggerInterfacePython.py" line="356"/>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="370"/>
         <source>Start Debugger</source>
-        <translation type="obsolete">Spustit debuger</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython.py" line="797"/>
+        <translation type="unfinished">Spustit debuger</translation>
+    </message>
+    <message>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="844"/>
         <source>Parent Process</source>
-        <translation type="obsolete">Rodičovský proces</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython.py" line="798"/>
+        <translation type="unfinished">Rodičovský proces</translation>
+    </message>
+    <message>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="845"/>
         <source>Child process</source>
-        <translation type="obsolete">Dětský proces</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython.py" line="799"/>
+        <translation type="unfinished">Dětský proces</translation>
+    </message>
+    <message>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="846"/>
         <source>Client forking</source>
-        <translation type="obsolete">Větvení klienta</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython.py" line="799"/>
+        <translation type="unfinished">Větvení klienta</translation>
+    </message>
+    <message>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="846"/>
         <source>Select the fork branch to follow.</source>
-        <translation type="obsolete">Pokračovat ve fork větvi.</translation>
+        <translation type="unfinished">Pokračovat ve fork větvi.</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython.py" line="147"/>
         <source>&lt;p&gt;No Python2 interpreter configured.&lt;/p&gt;</source>
         <translation type="obsolete">&lt;p&gt;Python2 interpreter není nakonfigurován.&lt;/p&gt;</translation>
     </message>
+    <message>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="152"/>
+        <source>&lt;p&gt;No {0} interpreter configured.&lt;/p&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="370"/>
+        <source>&lt;p&gt;The debugger backend could not be started.&lt;/p&gt;</source>
+        <translation type="unfinished">&lt;p&gt;Debugovací backend nelze spustit.&lt;/p&gt;</translation>
+    </message>
+    <message>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="891"/>
+        <source>Debug Protocol Error</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="891"/>
+        <source>&lt;p&gt;The response received from the debugger backend could not be decoded. Please report this issue with the received data to the eric bugs email address.&lt;/p&gt;&lt;p&gt;Error: {0}&lt;/p&gt;&lt;p&gt;Data:&lt;br/&gt;{0}&lt;/p&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
 </context>
 <context>
     <name>DebuggerInterfacePython2</name>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython2.py" line="348"/>
         <source>Start Debugger</source>
-        <translation type="unfinished">Spustit debuger</translation>
+        <translation type="obsolete">Spustit debuger</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython2.py" line="143"/>
         <source>&lt;p&gt;No Python2 interpreter configured.&lt;/p&gt;</source>
-        <translation type="unfinished">&lt;p&gt;Python2 interpreter není nakonfigurován.&lt;/p&gt;</translation>
+        <translation type="obsolete">&lt;p&gt;Python2 interpreter není nakonfigurován.&lt;/p&gt;</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython2.py" line="348"/>
         <source>&lt;p&gt;The debugger backend could not be started.&lt;/p&gt;</source>
-        <translation type="unfinished">&lt;p&gt;Debugovací backend nelze spustit.&lt;/p&gt;</translation>
+        <translation type="obsolete">&lt;p&gt;Debugovací backend nelze spustit.&lt;/p&gt;</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython2.py" line="822"/>
         <source>Parent Process</source>
-        <translation type="unfinished">Rodičovský proces</translation>
+        <translation type="obsolete">Rodičovský proces</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython2.py" line="823"/>
         <source>Child process</source>
-        <translation type="unfinished">Dětský proces</translation>
+        <translation type="obsolete">Dětský proces</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython2.py" line="824"/>
         <source>Client forking</source>
-        <translation type="unfinished">Větvení klienta</translation>
+        <translation type="obsolete">Větvení klienta</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython2.py" line="824"/>
         <source>Select the fork branch to follow.</source>
-        <translation type="unfinished">Pokračovat ve fork větvi.</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython2.py" line="869"/>
-        <source>Debug Protocol Error</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython2.py" line="869"/>
-        <source>&lt;p&gt;The response received from the debugger backend could not be decoded. Please report this issue with the received data to the eric bugs email address.&lt;/p&gt;&lt;p&gt;Error: {0}&lt;/p&gt;&lt;p&gt;Data:&lt;br/&gt;{0}&lt;/p&gt;</source>
-        <translation type="unfinished"></translation>
+        <translation type="obsolete">Pokračovat ve fork větvi.</translation>
     </message>
 </context>
 <context>
@@ -6772,47 +6782,37 @@
     <message>
         <location filename="../Debugger/DebuggerInterfacePython3.py" line="348"/>
         <source>Start Debugger</source>
-        <translation>Spustit debuger</translation>
+        <translation type="obsolete">Spustit debuger</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython3.py" line="348"/>
         <source>&lt;p&gt;The debugger backend could not be started.&lt;/p&gt;</source>
-        <translation>&lt;p&gt;Debugovací backend nelze spustit.&lt;/p&gt;</translation>
+        <translation type="obsolete">&lt;p&gt;Debugovací backend nelze spustit.&lt;/p&gt;</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython3.py" line="822"/>
         <source>Parent Process</source>
-        <translation>Rodičovský proces</translation>
+        <translation type="obsolete">Rodičovský proces</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython3.py" line="823"/>
         <source>Child process</source>
-        <translation>Dětský proces</translation>
+        <translation type="obsolete">Dětský proces</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython3.py" line="824"/>
         <source>Client forking</source>
-        <translation>Větvení klienta</translation>
+        <translation type="obsolete">Větvení klienta</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython3.py" line="824"/>
         <source>Select the fork branch to follow.</source>
-        <translation>Pokračovat ve fork větvi.</translation>
+        <translation type="obsolete">Pokračovat ve fork větvi.</translation>
     </message>
     <message>
         <location filename="../Debugger/DebuggerInterfacePython3.py" line="143"/>
         <source>&lt;p&gt;No Python3 interpreter configured.&lt;/p&gt;</source>
-        <translation type="unfinished">&lt;p&gt;Python2 interpreter není nakonfigurován.&lt;/p&gt; {3 ?}</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython3.py" line="869"/>
-        <source>Debug Protocol Error</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython3.py" line="869"/>
-        <source>&lt;p&gt;The response received from the debugger backend could not be decoded. Please report this issue with the received data to the eric bugs email address.&lt;/p&gt;&lt;p&gt;Error: {0}&lt;/p&gt;&lt;p&gt;Data:&lt;br/&gt;{0}&lt;/p&gt;</source>
-        <translation type="unfinished"></translation>
+        <translation type="obsolete">&lt;p&gt;Python2 interpreter není nakonfigurován.&lt;/p&gt; {3 ?}</translation>
     </message>
 </context>
 <context>
@@ -23075,12 +23075,12 @@
         <translation></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgAnnotateDialog.py" line="140"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgAnnotateDialog.py" line="141"/>
         <source>Process Generation Error</source>
         <translation>Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgAnnotateDialog.py" line="140"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgAnnotateDialog.py" line="141"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
@@ -23556,27 +23556,27 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="55"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="57"/>
         <source>Mercurial Incoming Bookmarks</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="57"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="59"/>
         <source>Mercurial Outgoing Bookmarks</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="144"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="146"/>
         <source>Process Generation Error</source>
         <translation type="unfinished">Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="144"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="146"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation type="unfinished">Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="177"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="179"/>
         <source>no bookmarks found</source>
         <translation type="unfinished"></translation>
     </message>
@@ -23666,82 +23666,82 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="146"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="147"/>
         <source>Process Generation Error</source>
         <translation type="unfinished">Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="146"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="147"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation type="unfinished">Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="185"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="186"/>
         <source>no bookmarks defined</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="46"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="47"/>
         <source>Refresh</source>
         <translation type="unfinished">Obnovit</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="48"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="49"/>
         <source>Press to refresh the bookmarks display</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="402"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="403"/>
         <source>Switch to</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="406"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="407"/>
         <source>Delete</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="409"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="410"/>
         <source>Rename</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="413"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="414"/>
         <source>Pull</source>
         <translation type="unfinished">Stáhnout</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="417"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="418"/>
         <source>Push</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="433"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="434"/>
         <source>Switch</source>
         <translation type="unfinished">Přepnout</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="433"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="434"/>
         <source>The project should be reread. Do this now?</source>
         <translation type="unfinished">Projekt bude znovu načten. Má se provést?</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="452"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="453"/>
         <source>Delete Bookmark</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="452"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="453"/>
         <source>&lt;p&gt;Shall the bookmark &lt;b&gt;{0}&lt;/b&gt; really be deleted?&lt;/p&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="468"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="469"/>
         <source>Rename Bookmark</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="468"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="469"/>
         <source>&lt;p&gt;Enter the new name for bookmark &lt;b&gt;{0}&lt;/b&gt;:&lt;/p&gt;</source>
         <translation type="unfinished"></translation>
     </message>
@@ -24132,7 +24132,7 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="246"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="247"/>
         <source>Resolved</source>
         <translation type="unfinished"></translation>
     </message>
@@ -24142,7 +24142,7 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="244"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="245"/>
         <source>Unresolved</source>
         <translation type="unfinished"></translation>
     </message>
@@ -24212,27 +24212,27 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="54"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="55"/>
         <source>&amp;Refresh</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="56"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="57"/>
         <source>Press to refresh the list of conflicts</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="157"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="158"/>
         <source>Process Generation Error</source>
         <translation type="unfinished">Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="157"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="158"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation type="unfinished">Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="248"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgConflictsListDialog.py" line="249"/>
         <source>Unknown Status</source>
         <translation type="unfinished"></translation>
     </message>
@@ -24367,12 +24367,12 @@
         <translation></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgDialog.py" line="171"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgDialog.py" line="172"/>
         <source>Process Generation Error</source>
         <translation>Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgDialog.py" line="171"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgDialog.py" line="172"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
@@ -24766,7 +24766,7 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/GpgExtension/HgGpgSignaturesDialog.py" line="317"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/GpgExtension/HgGpgSignaturesDialog.py" line="319"/>
         <source>Revision</source>
         <translation type="unfinished">Revize</translation>
     </message>
@@ -24841,17 +24841,17 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/GpgExtension/HgGpgSignaturesDialog.py" line="120"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/GpgExtension/HgGpgSignaturesDialog.py" line="122"/>
         <source>Process Generation Error</source>
         <translation type="unfinished">Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/GpgExtension/HgGpgSignaturesDialog.py" line="120"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/GpgExtension/HgGpgSignaturesDialog.py" line="122"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation type="unfinished">Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/GpgExtension/HgGpgSignaturesDialog.py" line="153"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/GpgExtension/HgGpgSignaturesDialog.py" line="155"/>
         <source>no signatures found</source>
         <translation type="unfinished"></translation>
     </message>
@@ -28325,42 +28325,42 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="199"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="201"/>
         <source>Process Generation Error</source>
         <translation type="unfinished">Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="199"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="201"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation type="unfinished">Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="232"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="234"/>
         <source>no patches found</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="60"/>
-        <source>applied</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
         <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="62"/>
+        <source>applied</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="64"/>
         <source>guarded</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="65"/>
+        <source>missing</source>
+        <translation type="unfinished">chybějící</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="308"/>
+        <source>unknown</source>
+        <translation type="unfinished">neznámý</translation>
+    </message>
+    <message>
         <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="63"/>
-        <source>missing</source>
-        <translation type="unfinished">chybějící</translation>
-    </message>
-    <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="306"/>
-        <source>unknown</source>
-        <translation type="unfinished">neznámý</translation>
-    </message>
-    <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/QueuesExtension/HgQueuesListDialog.py" line="61"/>
         <source>not applied</source>
         <translation type="unfinished"></translation>
     </message>
@@ -29243,42 +29243,42 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="56"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="58"/>
         <source>&amp;Refresh</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="58"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="60"/>
         <source>Press to refresh the list of shelves</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="75"/>
-        <source>Restore selected shelve</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
         <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="77"/>
-        <source>Delete selected shelves</source>
+        <source>Restore selected shelve</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
         <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="79"/>
+        <source>Delete selected shelves</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="81"/>
         <source>Delete all shelves</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="187"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="189"/>
         <source>Process Generation Error</source>
         <translation type="unfinished">Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="187"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="189"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation type="unfinished">Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
     <message numerus="yes">
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="373"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="375"/>
         <source>%n file(s) changed</source>
         <translation type="unfinished">
             <numerusform></numerusform>
@@ -29287,7 +29287,7 @@
         </translation>
     </message>
     <message numerus="yes">
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="375"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="377"/>
         <source>%n line(s) inserted</source>
         <translation type="unfinished">
             <numerusform></numerusform>
@@ -29296,7 +29296,7 @@
         </translation>
     </message>
     <message numerus="yes">
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="377"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/ShelveExtension/HgShelveBrowserDialog.py" line="379"/>
         <source>%n line(s) deleted</source>
         <translation type="unfinished">
             <numerusform></numerusform>
@@ -30178,72 +30178,72 @@
         <translation></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="111"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="112"/>
         <source>Mercurial Branches List</source>
         <translation>Mercurial sezam větví</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="112"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="113"/>
         <source>Status</source>
         <translation>Status</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="156"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="157"/>
         <source>Process Generation Error</source>
         <translation>Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="156"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="157"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="288"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="289"/>
         <source>active</source>
         <translation>aktivní</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="293"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="294"/>
         <source>yes</source>
         <translation>ano</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="49"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="50"/>
         <source>&amp;Refresh</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="51"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="52"/>
         <source>Press to refresh the list</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="433"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="434"/>
         <source>Switch to</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="477"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="478"/>
         <source>Close Branch</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="451"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="452"/>
         <source>Switch</source>
         <translation type="unfinished">Přepnout</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="451"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="452"/>
         <source>The project should be reread. Do this now?</source>
         <translation type="unfinished">Projekt bude znovu načten. Má se provést?</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="470"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="471"/>
         <source>The branch &quot;default&quot; cannot be closed. Aborting...</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="477"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgTagBranchListDialog.py" line="478"/>
         <source>&lt;p&gt;Shall the branch &lt;b&gt;{0}&lt;/b&gt; really be closed?&lt;/p&gt;</source>
         <translation type="unfinished"></translation>
     </message>
@@ -41087,22 +41087,22 @@
 <context>
     <name>PreviewProcessingThread</name>
     <message>
-        <location filename="../UI/Previewers/PreviewerHTML.py" line="461"/>
+        <location filename="../UI/Previewers/PreviewerHTML.py" line="483"/>
         <source>&lt;p&gt;No preview available for this type of file.&lt;/p&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
+        <location filename="../UI/Previewers/PreviewerHTML.py" line="652"/>
+        <source>&lt;p&gt;ReStructuredText preview requires the &lt;b&gt;python-docutils&lt;/b&gt; package.&lt;br/&gt;Install it with your package manager, &apos;pip install docutils&apos; or see &lt;a href=&quot;http://pypi.python.org/pypi/docutils&quot;&gt;this page.&lt;/a&gt;&lt;/p&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
         <location filename="../UI/Previewers/PreviewerHTML.py" line="596"/>
-        <source>&lt;p&gt;ReStructuredText preview requires the &lt;b&gt;python-docutils&lt;/b&gt; package.&lt;br/&gt;Install it with your package manager, &apos;pip install docutils&apos; or see &lt;a href=&quot;http://pypi.python.org/pypi/docutils&quot;&gt;this page.&lt;/a&gt;&lt;/p&gt;</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="../UI/Previewers/PreviewerHTML.py" line="540"/>
         <source>&lt;p&gt;ReStructuredText preview requires the &lt;b&gt;sphinx&lt;/b&gt; package.&lt;br/&gt;Install it with your package manager,&apos;pip install Sphinx&apos; or see &lt;a href=&quot;http://pypi.python.org/pypi/Sphinx&quot;&gt;this page.&lt;/a&gt;&lt;/p&gt;&lt;p&gt;Alternatively you may disable Sphinx usage on the Editor, Filehandling configuration page.&lt;/p&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../UI/Previewers/PreviewerHTML.py" line="624"/>
+        <location filename="../UI/Previewers/PreviewerHTML.py" line="680"/>
         <source>&lt;p&gt;Markdown preview requires the &lt;b&gt;python-markdown&lt;/b&gt; package.&lt;br/&gt;Install it with your package manager, &apos;pip install docutils&apos; or see &lt;a href=&quot;http://pythonhosted.org/Markdown/install.html&quot;&gt;installation instructions.&lt;/a&gt;&lt;/p&gt;</source>
         <translation type="unfinished"></translation>
     </message>
@@ -41110,37 +41110,37 @@
 <context>
     <name>PreviewerHTML</name>
     <message>
-        <location filename="../UI/Previewers/PreviewerHTML.py" line="75"/>
+        <location filename="../UI/Previewers/PreviewerHTML.py" line="77"/>
         <source>Select to enable JavaScript for HTML previews</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../UI/Previewers/PreviewerHTML.py" line="74"/>
+        <location filename="../UI/Previewers/PreviewerHTML.py" line="76"/>
         <source>Enable JavaScript</source>
         <translation type="unfinished">Zapnout JavaScript</translation>
     </message>
     <message>
+        <location filename="../UI/Previewers/PreviewerHTML.py" line="83"/>
+        <source>Select to enable support for Server Side Includes</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
         <location filename="../UI/Previewers/PreviewerHTML.py" line="81"/>
-        <source>Select to enable support for Server Side Includes</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
-        <location filename="../UI/Previewers/PreviewerHTML.py" line="79"/>
         <source>Enable Server Side Includes</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../UI/Previewers/PreviewerHTML.py" line="178"/>
+        <location filename="../UI/Previewers/PreviewerHTML.py" line="190"/>
         <source>&lt;p&gt;No preview available for this type of file.&lt;/p&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../UI/Previewers/PreviewerHTML.py" line="232"/>
+        <location filename="../UI/Previewers/PreviewerHTML.py" line="252"/>
         <source>Preview - {0}</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../UI/Previewers/PreviewerHTML.py" line="234"/>
+        <location filename="../UI/Previewers/PreviewerHTML.py" line="254"/>
         <source>Preview</source>
         <translation type="unfinished"></translation>
     </message>
@@ -55487,12 +55487,12 @@
         <translation></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnBlameDialog.py" line="102"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnBlameDialog.py" line="103"/>
         <source>Process Generation Error</source>
         <translation>Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnBlameDialog.py" line="102"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnBlameDialog.py" line="103"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
@@ -55567,22 +55567,22 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnChangeListsDialog.py" line="88"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnChangeListsDialog.py" line="89"/>
         <source>Files (relative to {0}):</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnChangeListsDialog.py" line="149"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnChangeListsDialog.py" line="150"/>
         <source>No changelists found</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnChangeListsDialog.py" line="119"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnChangeListsDialog.py" line="120"/>
         <source>Process Generation Error</source>
         <translation type="unfinished">Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnChangeListsDialog.py" line="119"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnChangeListsDialog.py" line="120"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation type="unfinished">Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
@@ -55857,7 +55857,7 @@
         <translation></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDialog.py" line="156"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDialog.py" line="157"/>
         <source>Process Generation Error</source>
         <translation>Chyba v procesu generování</translation>
     </message>
@@ -55867,7 +55867,7 @@
         <translation> (binární)</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDialog.py" line="156"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDialog.py" line="157"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
@@ -55977,22 +55977,22 @@
         <translation></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="193"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="194"/>
         <source>Process Generation Error</source>
         <translation>Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="213"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="214"/>
         <source>There is no difference.</source>
         <translation>Žádné rozdíly nebyly nalezeny.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="406"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="407"/>
         <source>Save Diff</source>
         <translation>Uložit Diff</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="373"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="374"/>
         <source>Patch Files (*.diff)</source>
         <translation>Patch soubory (*.diff)</translation>
     </message>
@@ -56002,12 +56002,12 @@
         <translation>Zamčené soubory nejsou dostupné/vybrané.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="193"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="194"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="406"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="407"/>
         <source>&lt;p&gt;The patch file &lt;b&gt;{0}&lt;/b&gt; could not be saved.&lt;br&gt;Reason: {1}&lt;/p&gt;</source>
         <translation>&lt;p&gt;Patch soubor &lt;b&gt;{0}&lt;/b&gt; nelze uložit.&lt;br /&gt;Důvod: {1}&lt;/p&gt;</translation>
     </message>
@@ -56018,27 +56018,27 @@
         <translation>Spouštím proces &apos;{0}&apos;...</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="390"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="391"/>
         <source>&lt;p&gt;The patch file &lt;b&gt;{0}&lt;/b&gt; already exists. Overwrite it?&lt;/p&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="226"/>
-        <source>&lt;Start&gt;</source>
-        <translation type="unfinished"></translation>
-    </message>
-    <message>
         <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="227"/>
+        <source>&lt;Start&gt;</source>
+        <translation type="unfinished"></translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="228"/>
         <source>&lt;End&gt;</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="48"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="49"/>
         <source>Refresh</source>
         <translation type="unfinished">Obnovit</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="50"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnDiffDialog.py" line="51"/>
         <source>Press to refresh the display</source>
         <translation type="unfinished"></translation>
     </message>
@@ -56194,12 +56194,12 @@
         <translation></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="661"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="662"/>
         <source>Revision</source>
         <translation>Revize</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="658"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="659"/>
         <source>Author</source>
         <translation>Autor</translation>
     </message>
@@ -56209,7 +56209,7 @@
         <translation>Datum</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="165"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="166"/>
         <source>Message</source>
         <translation>Zpráva</translation>
     </message>
@@ -56269,17 +56269,17 @@
         <translation>&amp;Porovnat revize</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="93"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="94"/>
         <source>Added</source>
         <translation>Přidáno</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="94"/>
-        <source>Deleted</source>
-        <translation>Smazáno</translation>
-    </message>
-    <message>
         <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="95"/>
+        <source>Deleted</source>
+        <translation>Smazáno</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="96"/>
         <source>Modified</source>
         <translation>Změněno</translation>
     </message>
@@ -56339,7 +56339,7 @@
         <translation></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="313"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="314"/>
         <source>Process Generation Error</source>
         <translation>Chyba v procesu generování</translation>
     </message>
@@ -56384,12 +56384,12 @@
         <translation>Zatavit kopírování/přesun</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="313"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="314"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="96"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnLogBrowserDialog.py" line="97"/>
         <source>Replaced</source>
         <translation type="unfinished"></translation>
     </message>
@@ -57871,7 +57871,7 @@
         <translation></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnRepoBrowserDialog.py" line="268"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnRepoBrowserDialog.py" line="269"/>
         <source>Process Generation Error</source>
         <translation>Chyba v procesu generování</translation>
     </message>
@@ -57886,7 +57886,7 @@
         <translation>Instalovaná verze PySvn by měla být 1.4.0 nebo vyšší.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnRepoBrowserDialog.py" line="268"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnRepoBrowserDialog.py" line="269"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
@@ -58002,7 +58002,7 @@
 <context>
     <name>SvnStatusDialog</name>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="394"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="395"/>
         <source>Subversion Status</source>
         <translation></translation>
     </message>
@@ -58114,192 +58114,192 @@
         <translation></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="59"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="60"/>
         <source>Refresh</source>
         <translation>Obnovit</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="61"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="62"/>
         <source>Press to refresh the status display</source>
         <translation>Stisknout pro obnovení statusu</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="84"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="85"/>
         <source>Commit changes to repository...</source>
         <translation>Komitnout změny do repozitáře...</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="859"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="860"/>
         <source>Lock</source>
         <translation>Zamknout</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="876"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="877"/>
         <source>Unlock</source>
         <translation>Odemknout</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="114"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="115"/>
         <source>Break lock</source>
         <translation>Prolomit zámek</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="117"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="118"/>
         <source>Steal lock</source>
         <translation>Zcizit zámek</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="121"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="122"/>
         <source>Adjust column sizes</source>
         <translation>Přizpůsobit šířky sloupců</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="161"/>
-        <source>added</source>
-        <translation>přidáno</translation>
-    </message>
-    <message>
         <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="162"/>
+        <source>added</source>
+        <translation>přidáno</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="163"/>
         <source>deleted</source>
         <translation>smazáno</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="174"/>
-        <source>modified</source>
-        <translation>změněno</translation>
-    </message>
-    <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="191"/>
-        <source>locked</source>
-        <translation>zamčeno</translation>
-    </message>
-    <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="192"/>
-        <source>other lock</source>
-        <translation>jiný zámek</translation>
-    </message>
-    <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="193"/>
-        <source>stolen lock</source>
-        <translation>scizený zámek</translation>
-    </message>
-    <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="194"/>
-        <source>broken lock</source>
-        <translation>prolomený zámek</translation>
-    </message>
-    <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="190"/>
-        <source>not locked</source>
-        <translation>nezamčeno</translation>
-    </message>
-    <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="173"/>
-        <source>normal</source>
-        <translation>normální</translation>
-    </message>
-    <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="164"/>
-        <source>replaced</source>
-        <translation>nahrazeno</translation>
-    </message>
-    <message>
         <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="175"/>
+        <source>modified</source>
+        <translation>změněno</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="192"/>
+        <source>locked</source>
+        <translation>zamčeno</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="193"/>
+        <source>other lock</source>
+        <translation>jiný zámek</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="194"/>
+        <source>stolen lock</source>
+        <translation>scizený zámek</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="195"/>
+        <source>broken lock</source>
+        <translation>prolomený zámek</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="191"/>
+        <source>not locked</source>
+        <translation>nezamčeno</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="174"/>
+        <source>normal</source>
+        <translation>normální</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="165"/>
+        <source>replaced</source>
+        <translation>nahrazeno</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="176"/>
         <source>conflict</source>
         <translation>konflikt</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="166"/>
-        <source>external</source>
-        <translation>externí</translation>
-    </message>
-    <message>
         <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="167"/>
-        <source>ignored</source>
-        <translation>ignorováno</translation>
+        <source>external</source>
+        <translation>externí</translation>
     </message>
     <message>
         <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="168"/>
-        <source>unversioned</source>
-        <translation>mimo verzi</translation>
+        <source>ignored</source>
+        <translation>ignorováno</translation>
     </message>
     <message>
         <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="169"/>
-        <source>missing</source>
-        <translation>chybějící</translation>
+        <source>unversioned</source>
+        <translation>mimo verzi</translation>
     </message>
     <message>
         <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="170"/>
+        <source>missing</source>
+        <translation>chybějící</translation>
+    </message>
+    <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="171"/>
         <source>type error</source>
         <translation>chyba typu</translation>
     </message>
     <message>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="199"/>
+        <source>no</source>
+        <translation>ne</translation>
+    </message>
+    <message>
         <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="198"/>
-        <source>no</source>
-        <translation>ne</translation>
-    </message>
-    <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="197"/>
         <source>yes</source>
         <translation>ano</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="401"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="402"/>
         <source>Process Generation Error</source>
         <translation>Chyba v procesu generování</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="711"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="712"/>
         <source>Commit</source>
         <translation>Commit</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="836"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="837"/>
         <source>There are no uncommitted changes available/selected.</source>
         <translation>Nezapsané změny nejsou dostupné/vybrané.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="859"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="860"/>
         <source>There are no unlocked files available/selected.</source>
         <translation>Odemčené soubory nejsou dostupné/vybrané.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="912"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="913"/>
         <source>There are no locked files available/selected.</source>
         <translation>Zamčené soubory nejsou dostupné/vybrané.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="894"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="895"/>
         <source>Break Lock</source>
         <translation>Prolomit zámek</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="912"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="913"/>
         <source>Steal Lock</source>
         <translation>Scizit zámek</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="91"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="92"/>
         <source>Add to repository</source>
         <translation>Přidat do repozitáře</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="97"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="98"/>
         <source>Revert changes</source>
         <translation>Vrátit změny</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="751"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="752"/>
         <source>Add</source>
         <translation>Přidat</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="751"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="752"/>
         <source>There are no unversioned entries available/selected.</source>
         <translation>Položky mimo verzi nejsou dostupné/vybrány.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="797"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="798"/>
         <source>Revert</source>
         <translation>Vrátit</translation>
     </message>
@@ -58309,27 +58309,27 @@
         <translation>Seznam změn</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="103"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="104"/>
         <source>Add to Changelist</source>
         <translation>Přidat do seznamu změn</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="948"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="949"/>
         <source>Remove from Changelist</source>
         <translation>Odebrat ze seznamu změn</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="929"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="930"/>
         <source>There are no files available/selected not belonging to a changelist.</source>
         <translation>Nejsou dostupné/vybrány soubory, které nepatří do seznamu změn.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="948"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="949"/>
         <source>There are no files available/selected belonging to a changelist.</source>
         <translation>Nejsou dostupné/vybrány soubory, které patří do seznamu změn.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="401"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="402"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
@@ -58394,42 +58394,42 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="93"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="94"/>
         <source>Show differences</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="99"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="100"/>
         <source>Restore missing</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="623"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="624"/>
         <source>all</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="815"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="816"/>
         <source>Differences</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="711"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="712"/>
         <source>There are no entries selected to be committed.</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="797"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="798"/>
         <source>There are no missing entries available/selected.</source>
         <translation type="unfinished">Chybějící záznamy nejsou dostupné/vybrány.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="86"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="87"/>
         <source>Select all for commit</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="88"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="89"/>
         <source>Deselect all from commit</source>
         <translation type="unfinished"></translation>
     </message>
@@ -58444,17 +58444,17 @@
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="95"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="96"/>
         <source>Show differences side-by-side</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="843"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="844"/>
         <source>Side-by-Side Diff</source>
         <translation type="unfinished"></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="843"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnStatusDialog.py" line="844"/>
         <source>Only one file with uncommitted changes must be selected.</source>
         <translation type="unfinished"></translation>
     </message>
@@ -58627,42 +58627,42 @@
         <translation></translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="94"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="95"/>
         <source>Subversion Branches List</source>
         <translation>Subversion seznam větví</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="124"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="125"/>
         <source>Subversion Error</source>
         <translation>Subversion chyba</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="105"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="106"/>
         <source>The URL of the project repository could not be retrieved from the working copy. The list operation will be aborted</source>
         <translation>Z pracovní kopie se nepodařilo se získat URL repozitáře. Sestavení seznamu bylo zrušeno</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="124"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="125"/>
         <source>The URL of the project repository has an invalid format. The list operation will be aborted</source>
         <translation>URL repozitáře projektu má neplatný formát. Sestavení seznamu bylo zrušeno</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="152"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="153"/>
         <source>Subversion List</source>
         <translation>Subversion seznam</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="141"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="142"/>
         <source>Enter the repository URL containing the tags or branches</source>
         <translation>Zadejte URL repozitáře obsahující tagy nebo větve</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="152"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="153"/>
         <source>The repository URL is empty. Aborting...</source>
         <translation>URL repozitáře je prázdný. Zrušeno...</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="169"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="170"/>
         <source>Process Generation Error</source>
         <translation>Chyba v procesu generování</translation>
     </message>
@@ -58672,7 +58672,7 @@
         <translation>Instalovaná verze PySvn by měla být 1.4.0 nebo vyšší.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="169"/>
+        <location filename="../Plugins/VcsPlugins/vcsSubversion/SvnTagBranchListDialog.py" line="170"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Proces {0} nelze spustit. Ověřte, že je umístěn v požadované cestě.</translation>
     </message>
Binary file i18n/eric6_de.qm has changed
--- a/i18n/eric6_de.ts	Sat Aug 26 17:10:43 2017 +0200
+++ b/i18n/eric6_de.ts	Sat Aug 26 19:26:07 2017 +0200
@@ -5395,24 +5395,24 @@
 <context>
     <name>DebugServer</name>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="177"/>
+        <location filename="../Debugger/DebugServer.py" line="179"/>
         <source>created</source>
         <comment>must be same as in EditWatchpointDialog</comment>
         <translation>erzeugt</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="179"/>
+        <location filename="../Debugger/DebugServer.py" line="181"/>
         <source>changed</source>
         <comment>must be same as in EditWatchpointDialog</comment>
         <translation>geändert</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="733"/>
+        <location filename="../Debugger/DebugServer.py" line="744"/>
         <source>Connection from illegal host</source>
         <translation>Verbindung von ungültigem Rechner</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="1353"/>
+        <location filename="../Debugger/DebugServer.py" line="1364"/>
         <source>
 Not connected
 </source>
@@ -5421,31 +5421,31 @@
 </translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="733"/>
+        <location filename="../Debugger/DebugServer.py" line="744"/>
         <source>&lt;p&gt;A connection was attempted by the illegal host &lt;b&gt;{0}&lt;/b&gt;. Accept this connection?&lt;/p&gt;</source>
         <translation>&lt;p&gt;Es wurde versucht, eine Verbindung von dem nicht zugelassenen Rechner &lt;b&gt;{0}&lt;/b&gt; aufzubauen. Soll die Verbindung angenommen werden?&lt;/p&gt;</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="1533"/>
+        <location filename="../Debugger/DebugServer.py" line="1544"/>
         <source>Passive debug connection received
 </source>
         <translation>Verbindung für passives Debuggen empfangen
 </translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="1547"/>
+        <location filename="../Debugger/DebugServer.py" line="1558"/>
         <source>Passive debug connection closed
 </source>
         <translation>Verbindung für passives Debuggen geschlossen
 </translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="321"/>
+        <location filename="../Debugger/DebugServer.py" line="323"/>
         <source>Register Debugger Interface</source>
         <translation>Debuggerschnittstelle registrieren</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebugServer.py" line="321"/>
+        <location filename="../Debugger/DebugServer.py" line="323"/>
         <source>&lt;p&gt;The debugger interface &lt;b&gt;{0}&lt;/b&gt; has already been registered. Ignoring this request.&lt;/p&gt;</source>
         <translation>&lt;p&gt;Die Debuggerschnittstelle &lt;b&gt;{0}&lt;/b&gt; wurde bereits registriert. Anfrage wird ignoriert.&lt;/p&gt;</translation>
     </message>
@@ -6557,97 +6557,49 @@
     </message>
 </context>
 <context>
-    <name>DebuggerInterfacePython2</name>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython2.py" line="348"/>
+    <name>DebuggerInterfacePython</name>
+    <message>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="370"/>
         <source>Start Debugger</source>
         <translation>Debugger starten</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebuggerInterfacePython2.py" line="143"/>
-        <source>&lt;p&gt;No Python2 interpreter configured.&lt;/p&gt;</source>
-        <translation>&lt;p&gt;Kein Python 2-Interpreter gefunden.&lt;/p&gt;</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython2.py" line="348"/>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="152"/>
+        <source>&lt;p&gt;No {0} interpreter configured.&lt;/p&gt;</source>
+        <translation>&lt;p&gt;Kein {0}-Interpreter gefunden.&lt;/p&gt;</translation>
+    </message>
+    <message>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="370"/>
         <source>&lt;p&gt;The debugger backend could not be started.&lt;/p&gt;</source>
         <translation>&lt;p&gt;Der Debugger konnte nicht gestartet werden.&lt;/p&gt;</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebuggerInterfacePython2.py" line="822"/>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="844"/>
         <source>Parent Process</source>
         <translation>Vaterprozess</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebuggerInterfacePython2.py" line="823"/>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="845"/>
         <source>Child process</source>
         <translation>Kindprozess</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebuggerInterfacePython2.py" line="824"/>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="846"/>
         <source>Client forking</source>
         <translation>Client forkt</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebuggerInterfacePython2.py" line="824"/>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="846"/>
         <source>Select the fork branch to follow.</source>
         <translation>Wähle den zu folgenden Forkpfad.</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebuggerInterfacePython2.py" line="869"/>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="891"/>
         <source>Debug Protocol Error</source>
         <translation>Fehler im Debugprotokoll</translation>
     </message>
     <message>
-        <location filename="../Debugger/DebuggerInterfacePython2.py" line="869"/>
-        <source>&lt;p&gt;The response received from the debugger backend could not be decoded. Please report this issue with the received data to the eric bugs email address.&lt;/p&gt;&lt;p&gt;Error: {0}&lt;/p&gt;&lt;p&gt;Data:&lt;br/&gt;{0}&lt;/p&gt;</source>
-        <translation>&lt;p&gt;Die vom Debugger empfangene Antwort konnte nicht dekodiert werden. Bitte berichten sie diesen Fehler zusammen mit den empfangenen Daten an die eric Bugs Emailadresse.&lt;/p&gt;&lt;p&gt;Fehler: {0}&lt;/p&gt;&lt;p&gt;Daten:&lt;br/&gt;{0}&lt;/p&gt;</translation>
-    </message>
-</context>
-<context>
-    <name>DebuggerInterfacePython3</name>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython3.py" line="348"/>
-        <source>Start Debugger</source>
-        <translation>Debugger starten</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython3.py" line="348"/>
-        <source>&lt;p&gt;The debugger backend could not be started.&lt;/p&gt;</source>
-        <translation>&lt;p&gt;Der Debugger konnte nicht gestartet werden.&lt;/p&gt;</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython3.py" line="822"/>
-        <source>Parent Process</source>
-        <translation>Vaterprozess</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython3.py" line="823"/>
-        <source>Child process</source>
-        <translation>Kindprozess</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython3.py" line="824"/>
-        <source>Client forking</source>
-        <translation>Client forkt</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython3.py" line="824"/>
-        <source>Select the fork branch to follow.</source>
-        <translation>Wähle den zu folgenden Forkpfad.</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython3.py" line="143"/>
-        <source>&lt;p&gt;No Python3 interpreter configured.&lt;/p&gt;</source>
-        <translation>&lt;p&gt;Kein Python 3-Interpreter gefunden.&lt;/p&gt;</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython3.py" line="869"/>
-        <source>Debug Protocol Error</source>
-        <translation>Fehler im Debugprotokoll</translation>
-    </message>
-    <message>
-        <location filename="../Debugger/DebuggerInterfacePython3.py" line="869"/>
+        <location filename="../Debugger/DebuggerInterfacePython.py" line="891"/>
         <source>&lt;p&gt;The response received from the debugger backend could not be decoded. Please report this issue with the received data to the eric bugs email address.&lt;/p&gt;&lt;p&gt;Error: {0}&lt;/p&gt;&lt;p&gt;Data:&lt;br/&gt;{0}&lt;/p&gt;</source>
         <translation>&lt;p&gt;Die vom Debugger empfangene Antwort konnte nicht dekodiert werden. Bitte berichten sie diesen Fehler zusammen mit den empfangenen Daten an die eric Bugs Emailadresse.&lt;/p&gt;&lt;p&gt;Fehler: {0}&lt;/p&gt;&lt;p&gt;Daten:&lt;br/&gt;{0}&lt;/p&gt;</translation>
     </message>
@@ -22516,12 +22468,12 @@
         <translation>Alt+P</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgAnnotateDialog.py" line="140"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgAnnotateDialog.py" line="141"/>
         <source>Process Generation Error</source>
         <translation>Fehler beim Prozessstart</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgAnnotateDialog.py" line="140"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgAnnotateDialog.py" line="141"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Der Prozess {0} konnte nicht gestartet werden. Stellen Sie sicher, dass er sich im Suchpfad befindet.</translation>
     </message>
@@ -22998,27 +22950,27 @@
         <translation>Alt+P</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="55"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="57"/>
         <source>Mercurial Incoming Bookmarks</source>
         <translation>Eingehende Mercurial-Lesezeichen</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="57"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="59"/>
         <source>Mercurial Outgoing Bookmarks</source>
         <translation>Ausgehende Mercurial-Lesezeichen</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="144"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="146"/>
         <source>Process Generation Error</source>
         <translation>Fehler beim Prozessstart</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="144"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="146"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Der Prozess {0} konnte nicht gestartet werden. Stellen Sie sicher, dass er sich im Suchpfad befindet.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="177"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksInOutDialog.py" line="179"/>
         <source>no bookmarks found</source>
         <translation>keine Lesezeichen vorhanden</translation>
     </message>
@@ -23110,82 +23062,82 @@
         <translation>Alt+P</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="146"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="147"/>
         <source>Process Generation Error</source>
         <translation>Fehler beim Prozessstart</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="146"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="147"/>
         <source>The process {0} could not be started. Ensure, that it is in the search path.</source>
         <translation>Der Prozess {0} konnte nicht gestartet werden. Stellen Sie sicher, dass er sich im Suchpfad befindet.</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="185"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="186"/>
         <source>no bookmarks defined</source>
         <translation>keine Lesezeichen vorhanden</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="46"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="47"/>
         <source>Refresh</source>
         <translation>Erneuern</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="48"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="49"/>
         <source>Press to refresh the bookmarks display</source>
         <translation>Drücken, um die Lesezeichenanzeige zu erneuern</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="402"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="403"/>
         <source>Switch to</source>
         <translation>Umschalten</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="406"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="407"/>
         <source>Delete</source>
         <translation>Löschen</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="409"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="410"/>
         <source>Rename</source>
         <translation>Umbenennen</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="413"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="414"/>
         <source>Pull</source>
         <translation>Pull</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="417"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="418"/>
         <source>Push</source>
         <translation>Push</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="433"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="434"/>
         <source>Switch</source>
         <translation>Umschalten</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="433"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="434"/>
         <source>The project should be reread. Do this now?</source>
         <translation>Das Projekt sollte neu gelesen werde. Jetzt durchführen?</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="452"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="453"/>
         <source>Delete Bookmark</source>
         <translation>Lesezeichen löschen</translation>
     </message>
     <message>
-        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="452"/>
+        <location filename="../Plugins/VcsPlugins/vcsMercurial/HgBookmarksListDialog.py" line="453"/>
         <source>&lt;p&gt;Shall the bookmark &lt;b&gt;{0}&lt;/b&gt; really be deleted?&lt;/p&gt;</source>
         <translation>&lt;p&gt;Soll das Lesezeichen &lt;b&gt;{0}&lt;/b&gt; wirklich gelöscht werden?&lt;/p&gt;</translation>
     </message>
     <message>