eric: eric6/Debugger/DebugUI.py@1413bfe73d41 (annotated)

5b1b59777460 Added a feature where flags can be given at the end of a source file. The only flag supported is 'FileType' to overwrite the filetype detection mechanism.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 768

diff changeset

834

if editor.isPy2File():

0

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

836

elif editor.isPy3File():

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

838

elif editor.isRubyFile():

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

840

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

842

self.runAct.setEnabled(cap & HasInterpreter)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

844

self.profileAct.setEnabled(cap & HasProfiler)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

846

self.dbgSetBpActGrp.setEnabled(cap & HasDebugger)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

848

self.dbgEditBpAct.setEnabled(True)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

850

self.dbgEditBpAct.setEnabled(False)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

852

self.dbgNextBpAct.setEnabled(True)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

854

else:

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

856

self.dbgPrevBpAct.setEnabled(False)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

858

self.runAct.setEnabled(False)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

860

self.profileAct.setEnabled(False)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

862

self.dbgSetBpActGrp.setEnabled(False)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

864

def __cursorChanged(self, editor):

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

866

Private slot handling the cursorChanged signal of the viewmanager.

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

868

@param editor editor window

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

870

if editor is None:

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

872

0

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

874

if editor.curLineHasBreakpoint():

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

876

else:

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

878

if editor.hasBreakpoints():

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

880

self.dbgPrevBpAct.setEnabled(True)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

882

self.dbgNextBpAct.setEnabled(False)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

884

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

886

"""

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

888

"""

564

b3d966393ba9 Did some code cleanup.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 553

diff changeset

890

cap = self.debugServer.getClientCapabilities(

0

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

892

if not self.passive:

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

894

self.runProjectAct.setEnabled(cap & HasInterpreter)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

896

self.coverageProjectAct.setEnabled(cap & HasCoverage)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

898

def __projectClosed(self):

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

900

Private slot to handle the projectClosed signal.

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

902

self.projectOpen = False

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

904

self.profileProjectAct.setEnabled(False)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

906

self.debugProjectAct.setEnabled(False)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

908

if not self.editorOpen:

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

910

self.lastDebuggedFile = None

795

917f1945355c Added a syntax checker function for Python 2 files.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 791

diff changeset

912

self.clientType = ""

5108

f5cb9cb98e6a Added an action to clear the private data of the IDE.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5100

diff changeset

914

def clearHistories(self):

f5cb9cb98e6a Added an action to clear the private data of the IDE.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5100

diff changeset

916

Public method to clear the various debug histories.

f5cb9cb98e6a Added an action to clear the private data of the IDE.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5100

diff changeset

918

self.argvHistory = []

f5cb9cb98e6a Added an action to clear the private data of the IDE.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5100

diff changeset

920

self.envHistory = []

f5cb9cb98e6a Added an action to clear the private data of the IDE.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5100

diff changeset

922

Preferences.Prefs.settings.setValue(

f5cb9cb98e6a Added an action to clear the private data of the IDE.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5100

diff changeset

924

Preferences.Prefs.settings.setValue(

f5cb9cb98e6a Added an action to clear the private data of the IDE.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5100

diff changeset

926

Preferences.Prefs.settings.setValue(

f5cb9cb98e6a Added an action to clear the private data of the IDE.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5100

diff changeset

928

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

930

"""

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

932

"""

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

934

del self.argvHistory[10:]

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

936

del self.envHistory[10:]

3021

801289962f4e Fixed a bunch of visible indentation issues.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 3020

diff changeset

938

Preferences.Prefs.settings.setValue(

5899

0516f6548ca6 Added the capability to enter an interpreter in the Start... dialogs of the debugger.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5663

diff changeset

940

Preferences.Prefs.settings.setValue(

2988

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

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 2703

diff changeset

942

Preferences.Prefs.settings.setValue(

3021

801289962f4e Fixed a bunch of visible indentation issues.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 3020

diff changeset

944

Preferences.Prefs.settings.setValue(

801289962f4e Fixed a bunch of visible indentation issues.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 3020

diff changeset

946

Preferences.Prefs.settings.setValue(

801289962f4e Fixed a bunch of visible indentation issues.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 3020

diff changeset

948

Preferences.Prefs.settings.setValue(

801289962f4e Fixed a bunch of visible indentation issues.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 3020

diff changeset

950

Preferences.Prefs.settings.setValue(

801289962f4e Fixed a bunch of visible indentation issues.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 3020

diff changeset

952

Preferences.Prefs.settings.setValue(

801289962f4e Fixed a bunch of visible indentation issues.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 3020

diff changeset

954

Preferences.Prefs.settings.setValue(

801289962f4e Fixed a bunch of visible indentation issues.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 3020

diff changeset

956

Preferences.Prefs.settings.setValue(

801289962f4e Fixed a bunch of visible indentation issues.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 3020

diff changeset

958

Preferences.Prefs.settings.setValue(

801289962f4e Fixed a bunch of visible indentation issues.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 3020

diff changeset

960

Preferences.Prefs.settings.setValue(

7409

1413bfe73d41 Continued with the multiprocess debugger.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 7408

diff changeset

962

Preferences.Prefs.settings.setValue(

0

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

964

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

966

"""

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

968

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

970

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

972

"""

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

974

return True

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

976

def __resetUI(self):

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

978

Private slot to reset the user interface.

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

980

self.lastAction = -1

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

982

if not self.passive:

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

984

editor = self.viewmanager.activeWindow()

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

986

editor = None

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

988

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

990

self.runProjectAct.setEnabled(self.projectOpen)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

992

self.coverageProjectAct.setEnabled(self.projectOpen)

bc5b1b00560a Continued to resolve code style issue M841.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 7229

diff changeset

994

self.lastDebuggedFile is not None and

bc5b1b00560a Continued to resolve code style issue M841.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 7229

diff changeset

996

):

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

998

else:

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

1000

self.stopAct.setEnabled(False)

0

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

1002

0

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

1004

"""

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

1006

cc920e534ac0 Continued with the multiprocess debugger.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 7374

diff changeset

1008

@type str

cc920e534ac0 Continued with the multiprocess debugger.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 7374

diff changeset

1010

@type int

cc920e534ac0 Continued with the multiprocess debugger.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 7374

diff changeset

1012

@type str

cc920e534ac0 Continued with the multiprocess debugger.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 7374

diff changeset

1014

@type bool

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

1016

self.ui.raise_()

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

1018

if self.ui.getViewProfile() != "debug":

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

1020

self.viewmanager.setFileLine(fn, line)

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

1022

self.__getThreadList()

0

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

1024

7379

72a72fd56494 Continued with the multiprocess debugger.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 7377

diff changeset

1026

6904

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1028

def __clientExit(self, status, message, quiet):

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

1030

Private method to handle the debugged program terminating.

5140

01484c0afbc6 Worked on the last TODOs for the modernized debugger protocol.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5136

diff changeset

1032

@param status exit code of the debugged program

01484c0afbc6 Worked on the last TODOs for the modernized debugger protocol.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5136

diff changeset

1034

@param message exit message of the debugged program

6904

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1036

@param quiet flag indicating to suppress exit info display

0

de9c2efb9d02 Started porting eric4 to Python3

Detlev Offenbach <detlev@die-offenbachs.de>

parents:

diff changeset

1038

"""

7251

bc5b1b00560a Continued to resolve code style issue M841.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 7229

diff changeset

1040

if (

bc5b1b00560a Continued to resolve code style issue M841.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 7229

diff changeset

1042

status != 0

6904

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1044

if message:

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1046

Utilities.html_uencode(message))

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1048

info = ""

6904

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1050

E5MessageBox.information(

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1052

self.tr('The program has terminated with an exit'

2191

7c7251ce9497 Changed a few places to use the new notification system.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 2171

diff changeset

1054

else:

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1056

self.ui, Program,

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1058

' status of {1}.{2}')

5136

b1dde2dc14bd Improved the handling of debug client exits.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 5130

diff changeset

1060

status, info))

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1062

if message:

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1064

Utilities.html_uencode(message))

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1066

info = ""

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1068

if self.ui.currentProg is None:

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1070

'The program has terminated with an exit status of'

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1072

else:

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1074

'"{0}" has terminated with an exit status of'

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1076

os.path.basename(self.ui.currentProg), status,

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1078

self.ui.showNotification(

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1080

self.tr("Program terminated"), msg)

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1082

if self.ui.currentProg is None:

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1084

'The program has terminated with an exit status'

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1086

else:

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1088

'"{0}" has terminated with an exit status of'

3f35037a08d4 Unit Test: added capability to run test with debugger support and to stop the test on the first error or failure.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 6645

diff changeset

1090

Utilities.normabspath(self.ui.currentProg), status,

7392

b6674724612a Continued with the multiprocess debugger.

Detlev Offenbach <detlev@die-offenbachs.de>

parents: 7389

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2020 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the debugger UI.
 """
 import os
 from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, Qt
 from PyQt5.QtGui import QKeySequence
 from PyQt5.QtWidgets import QMenu, QToolBar, QApplication, QDialog
 from UI.Info import Program
 from .DebugClientCapabilities import (
     HasDebugger, HasInterpreter, HasProfiler, HasCoverage
 )
 import Preferences
 import Utilities
 import UI.PixmapCache
 import UI.Config
 from E5Gui.E5Action import E5Action, createActionGroup
 from E5Gui import E5MessageBox
 from eric6config import getConfig
 class DebugUI(QObject):
     """
     Class implementing the debugger part of the UI.
     @signal clientStack(stack, debuggerId) emitted at breaking after a reported
         exception
     @signal compileForms() emitted if changed project forms should be compiled
     @signal compileResources() emitted if changed project resources should be
         compiled
     @signal executeMake() emitted if a project specific make run should be
         performed
     @signal debuggingStarted(filename) emitted when a debugging session was
         started
     @signal resetUI() emitted to reset the UI
     @signal exceptionInterrupt() emitted after the execution was interrupted
         by an exception and acknowledged by the user
     @signal appendStdout(msg) emitted when the client program has terminated
         and the display of the termination dialog is suppressed
     """
     clientStack = pyqtSignal(list, str)
     resetUI = pyqtSignal()
     exceptionInterrupt = pyqtSignal()
     compileForms = pyqtSignal()
     compileResources = pyqtSignal()
     executeMake = pyqtSignal()
     debuggingStarted = pyqtSignal(str)
     appendStdout = pyqtSignal(str)
     def __init__(self, ui, vm, debugServer, debugViewer, project):
         """
         Constructor
         @param ui reference to the main UI
         @param vm reference to the viewmanager
         @param debugServer reference to the debug server
         @param debugViewer reference to the debug viewer widget
         @param project reference to the project object
         """
         super(DebugUI, self).__init__(ui)
         self.ui = ui
         self.viewmanager = vm
         self.debugServer = debugServer
         self.debugViewer = debugViewer
         self.project = project
         # Clear some variables
         self.projectOpen = False
         self.editorOpen = False
         # read the saved debug info values
         self.lastUsedVenvName = Preferences.Prefs.settings.value(
             'DebugInfo/VirtualEnvironment', '')
         self.argvHistory = Preferences.toList(
             Preferences.Prefs.settings.value('DebugInfo/ArgumentsHistory'))
         self.wdHistory = Preferences.toList(
             Preferences.Prefs.settings.value(
                 'DebugInfo/WorkingDirectoryHistory'))
         self.envHistory = Preferences.toList(
             Preferences.Prefs.settings.value('DebugInfo/EnvironmentHistory'))
         self.excList = Preferences.toList(
             Preferences.Prefs.settings.value('DebugInfo/Exceptions'))
         self.excIgnoreList = Preferences.toList(
             Preferences.Prefs.settings.value('DebugInfo/IgnoredExceptions'))
         self.exceptions = Preferences.toBool(
             Preferences.Prefs.settings.value(
                 'DebugInfo/ReportExceptions', True))
         self.autoClearShell = Preferences.toBool(
             Preferences.Prefs.settings.value('DebugInfo/AutoClearShell', True))
         self.tracePython = Preferences.toBool(
             Preferences.Prefs.settings.value('DebugInfo/TracePython', False))
         self.autoContinue = Preferences.toBool(
             Preferences.Prefs.settings.value('DebugInfo/AutoContinue', True))
         self.forkAutomatically = Preferences.toBool(
             Preferences.Prefs.settings.value(
                 'DebugInfo/ForkAutomatically', False))
         self.forkIntoChild = Preferences.toBool(
             Preferences.Prefs.settings.value('DebugInfo/ForkIntoChild', False))
         self.enableMultiprocess = Preferences.toBool(
             Preferences.Prefs.settings.value(
                 'DebugInfo/EnableMultiprocess', False))
         self.lastDebuggedFile = None
         self.lastStartAction = 0    # 0=None, 1=Script, 2=Project
         self.clientType = ""
         self.lastAction = -1
         self.debugActions = [
             self.__continue, self.__step, self.__stepOver, self.__stepOut,
             self.__stepQuit, self.__runToCursor, self.__moveInstructionPointer
         ]
         self.localsVarFilter, self.globalsVarFilter = (
             Preferences.getVarFilters())
         self.debugViewer.setVariablesFilter(
             self.globalsVarFilter, self.localsVarFilter)
         # Connect the signals emitted by the debug-server
         debugServer.clientGone.connect(self.__clientGone)
         debugServer.clientLine.connect(self.__clientLine)
         debugServer.clientExit.connect(self.__clientExit)
         debugServer.lastClientExited.connect(self.__lastClientExited)
         debugServer.clientSyntaxError.connect(self.__clientSyntaxError)
         debugServer.clientException.connect(self.__clientException)
         debugServer.clientSignal.connect(self.__clientSignal)
         debugServer.clientVariables.connect(self.__clientVariables)
         debugServer.clientVariable.connect(self.__clientVariable)
         debugServer.clientBreakConditionError.connect(
             self.__clientBreakConditionError)
         debugServer.clientWatchConditionError.connect(
             self.__clientWatchConditionError)
         debugServer.passiveDebugStarted.connect(self.__passiveDebugStarted)
         debugServer.clientThreadSet.connect(self.__clientThreadSet)
         # Connect the signals emitted by the viewmanager
         vm.editorOpened.connect(self.__editorOpened)
         vm.lastEditorClosed.connect(self.__lastEditorClosed)
         vm.checkActions.connect(self.__checkActions)
         vm.cursorChanged.connect(self.__cursorChanged)
         vm.breakpointToggled.connect(self.__cursorChanged)
         # Connect the signals emitted by the project
         project.projectOpened.connect(self.__projectOpened)
         project.newProject.connect(self.__projectOpened)
         project.projectClosed.connect(self.__projectClosed)
         # Set a flag for the passive debug mode
         self.passive = Preferences.getDebugger("PassiveDbgEnabled")
     def variablesFilter(self, scope):
         """
         Public method to get the variables filter for a scope.
         @param scope flag indicating global (True) or local (False) scope
         @return filters list (list of integers)
         """
         if scope:
             return self.globalsVarFilter[:]
         else:
             return self.localsVarFilter[:]
     def initActions(self):
         """
         Public method defining the user interface actions.
         """
         self.actions = []
         self.runAct = E5Action(
             self.tr('Run Script'),
             UI.PixmapCache.getIcon("runScript.png"),
             self.tr('&Run Script...'),
             Qt.Key_F2, 0, self, 'dbg_run_script')
         self.runAct.setStatusTip(self.tr('Run the current Script'))
         self.runAct.setWhatsThis(self.tr(
             """<b>Run Script</b>"""
             """<p>Set the command line arguments and run the script outside"""
             """ the debugger. If the file has unsaved changes it may be"""
             """ saved first.</p>"""
         ))
         self.runAct.triggered.connect(self.__runScript)
         self.actions.append(self.runAct)
         self.runProjectAct = E5Action(
             self.tr('Run Project'),
             UI.PixmapCache.getIcon("runProject.png"),
             self.tr('Run &Project...'), Qt.SHIFT + Qt.Key_F2, 0, self,
             'dbg_run_project')
         self.runProjectAct.setStatusTip(self.tr('Run the current Project'))
         self.runProjectAct.setWhatsThis(self.tr(
             """<b>Run Project</b>"""
             """<p>Set the command line arguments and run the current project"""
             """ outside the debugger."""
             """ If files of the current project have unsaved changes they"""
             """ may be saved first.</p>"""
         ))
         self.runProjectAct.triggered.connect(self.__runProject)
         self.actions.append(self.runProjectAct)
         self.coverageAct = E5Action(
             self.tr('Coverage run of Script'),
             UI.PixmapCache.getIcon("coverageScript.png"),
             self.tr('Coverage run of Script...'), 0, 0, self,
             'dbg_coverage_script')
         self.coverageAct.setStatusTip(
             self.tr('Perform a coverage run of the current Script'))
         self.coverageAct.setWhatsThis(self.tr(
             """<b>Coverage run of Script</b>"""
             """<p>Set the command line arguments and run the script under"""
             """ the control of a coverage analysis tool. If the file has"""
             """ unsaved changes it may be saved first.</p>"""
         ))
         self.coverageAct.triggered.connect(self.__coverageScript)
         self.actions.append(self.coverageAct)
         self.coverageProjectAct = E5Action(
             self.tr('Coverage run of Project'),
             UI.PixmapCache.getIcon("coverageProject.png"),
             self.tr('Coverage run of Project...'), 0, 0, self,
             'dbg_coverage_project')
         self.coverageProjectAct.setStatusTip(
             self.tr('Perform a coverage run of the current Project'))
         self.coverageProjectAct.setWhatsThis(self.tr(
             """<b>Coverage run of Project</b>"""
             """<p>Set the command line arguments and run the current project"""
             """ under the control of a coverage analysis tool."""
             """ If files of the current project have unsaved changes"""
             """ they may be saved first.</p>"""
         ))
         self.coverageProjectAct.triggered.connect(self.__coverageProject)
         self.actions.append(self.coverageProjectAct)
         self.profileAct = E5Action(
             self.tr('Profile Script'),
             UI.PixmapCache.getIcon("profileScript.png"),
             self.tr('Profile Script...'), 0, 0, self, 'dbg_profile_script')
         self.profileAct.setStatusTip(self.tr('Profile the current Script'))
         self.profileAct.setWhatsThis(self.tr(
             """<b>Profile Script</b>"""
             """<p>Set the command line arguments and profile the script."""
             """ If the file has unsaved changes it may be saved first.</p>"""
         ))
         self.profileAct.triggered.connect(self.__profileScript)
         self.actions.append(self.profileAct)
         self.profileProjectAct = E5Action(
             self.tr('Profile Project'),
             UI.PixmapCache.getIcon("profileProject.png"),
             self.tr('Profile Project...'), 0, 0, self,
             'dbg_profile_project')
         self.profileProjectAct.setStatusTip(
             self.tr('Profile the current Project'))
         self.profileProjectAct.setWhatsThis(self.tr(
             """<b>Profile Project</b>"""
             """<p>Set the command line arguments and profile the current"""
             """ project. If files of the current project have unsaved"""
             """ changes they may be saved first.</p>"""
         ))
         self.profileProjectAct.triggered.connect(self.__profileProject)
         self.actions.append(self.profileProjectAct)
         self.debugAct = E5Action(
             self.tr('Debug Script'),
             UI.PixmapCache.getIcon("debugScript.png"),
             self.tr('&Debug Script...'), Qt.Key_F5, 0, self,
             'dbg_debug_script')
         self.debugAct.setStatusTip(self.tr('Debug the current Script'))
         self.debugAct.setWhatsThis(self.tr(
             """<b>Debug Script</b>"""
             """<p>Set the command line arguments and set the current line"""
             """ to be the first executable Python statement of the current"""
             """ editor window. If the file has unsaved changes it may be"""
             """ saved first.</p>"""
         ))
         self.debugAct.triggered.connect(self.__debugScript)
         self.actions.append(self.debugAct)
         self.debugProjectAct = E5Action(
             self.tr('Debug Project'),
             UI.PixmapCache.getIcon("debugProject.png"),
             self.tr('Debug &Project...'), Qt.SHIFT + Qt.Key_F5, 0, self,
             'dbg_debug_project')
         self.debugProjectAct.setStatusTip(self.tr(
             'Debug the current Project'))
         self.debugProjectAct.setWhatsThis(self.tr(
             """<b>Debug Project</b>"""
             """<p>Set the command line arguments and set the current line"""
             """ to be the first executable Python statement of the main"""
             """ script of the current project. If files of the current"""
             """ project have unsaved changes they may be saved first.</p>"""
         ))
         self.debugProjectAct.triggered.connect(self.__debugProject)
         self.actions.append(self.debugProjectAct)
         self.restartAct = E5Action(
             self.tr('Restart'),
             UI.PixmapCache.getIcon("debugRestart.png"),
             self.tr('Restart'), Qt.Key_F4, 0, self, 'dbg_restart_script')
         self.restartAct.setStatusTip(self.tr(
             'Restart the last debugged script'))
         self.restartAct.setWhatsThis(self.tr(
             """<b>Restart</b>"""
             """<p>Set the command line arguments and set the current line"""
             """ to be the first executable Python statement of the script"""
             """ that was debugged last. If there are unsaved changes, they"""
             """ may be saved first.</p>"""
         ))
         self.restartAct.triggered.connect(self.__doRestart)
         self.actions.append(self.restartAct)
         self.stopAct = E5Action(
             self.tr('Stop'),
             UI.PixmapCache.getIcon("stopScript.png"),
             self.tr('Stop'), Qt.SHIFT + Qt.Key_F10, 0,
             self, 'dbg_stop_script')
         self.stopAct.setStatusTip(self.tr("""Stop the running script."""))
         self.stopAct.setWhatsThis(self.tr(
             """<b>Stop</b>"""
             """<p>This stops the script running in the debugger backend.</p>"""
         ))
         self.stopAct.triggered.connect(self.__stopScript)
         self.actions.append(self.stopAct)
         self.debugActGrp = createActionGroup(self)
         act = E5Action(
             self.tr('Continue'),
             UI.PixmapCache.getIcon("continue.png"),
             self.tr('&Continue'), Qt.Key_F6, 0,
             self.debugActGrp, 'dbg_continue')
         act.setStatusTip(
             self.tr('Continue running the program from the current line'))
         act.setWhatsThis(self.tr(
             """<b>Continue</b>"""
             """<p>Continue running the program from the current line. The"""
             """ program will stop when it terminates or when a breakpoint"""
             """ is reached.</p>"""
         ))
         act.triggered.connect(self.__continue)
         self.actions.append(act)
         act = E5Action(
             self.tr('Continue to Cursor'),
             UI.PixmapCache.getIcon("continueToCursor.png"),
             self.tr('Continue &To Cursor'), Qt.SHIFT + Qt.Key_F6, 0,
             self.debugActGrp, 'dbg_continue_to_cursor')
         act.setStatusTip(self.tr(
             """Continue running the program from the"""
             """ current line to the current cursor position"""))
         act.setWhatsThis(self.tr(
             """<b>Continue To Cursor</b>"""
             """<p>Continue running the program from the current line to the"""
             """ current cursor position.</p>"""
         ))
         act.triggered.connect(self.__runToCursor)
         self.actions.append(act)
         act = E5Action(
             self.tr('Move Instruction Pointer to Cursor'),
             UI.PixmapCache.getIcon("moveInstructionPointer.png"),
             self.tr('&Jump To Cursor'), Qt.Key_F12, 0,
             self.debugActGrp, 'dbg_jump_to_cursor')
         act.setStatusTip(self.tr(
             """Skip the code from the"""
             """ current line to the current cursor position"""))
         act.setWhatsThis(self.tr(
             """<b>Move Instruction Pointer to Cursor</b>"""
             """<p>Move the Python internal instruction pointer to the"""
             """ current cursor position without executing the code in"""
             """ between.</p>"""
             """<p>It's not possible to jump out of a function or jump"""
             """ in a code block, e.g. a loop. In these cases, a error"""
             """ message is printed to the log window.</p>"""
         ))
         act.triggered.connect(self.__moveInstructionPointer)
         self.actions.append(act)
         act = E5Action(
             self.tr('Single Step'),
             UI.PixmapCache.getIcon("step.png"),
             self.tr('Sin&gle Step'), Qt.Key_F7, 0,
             self.debugActGrp, 'dbg_single_step')
         act.setStatusTip(self.tr('Execute a single Python statement'))
         act.setWhatsThis(self.tr(
             """<b>Single Step</b>"""
             """<p>Execute a single Python statement. If the statement"""
             """ is an <tt>import</tt> statement, a class constructor, or a"""
             """ method or function call then control is returned to the"""
             """ debugger at the next statement.</p>"""
         ))
         act.triggered.connect(self.__step)
         self.actions.append(act)
         act = E5Action(
             self.tr('Step Over'),
             UI.PixmapCache.getIcon("stepOver.png"),
             self.tr('Step &Over'), Qt.Key_F8, 0,
             self.debugActGrp, 'dbg_step_over')
         act.setStatusTip(self.tr(
             """Execute a single Python statement staying"""
             """ in the current frame"""))
         act.setWhatsThis(self.tr(
             """<b>Step Over</b>"""
             """<p>Execute a single Python statement staying in the same"""
             """ frame. If the statement is an <tt>import</tt> statement,"""
             """ a class constructor, or a method or function call then"""
             """ control is returned to the debugger after the statement"""
             """ has completed.</p>"""
         ))
         act.triggered.connect(self.__stepOver)
         self.actions.append(act)
         act = E5Action(
             self.tr('Step Out'),
             UI.PixmapCache.getIcon("stepOut.png"),
             self.tr('Step Ou&t'), Qt.Key_F9, 0,
             self.debugActGrp, 'dbg_step_out')
         act.setStatusTip(self.tr(
             """Execute Python statements until leaving"""
             """ the current frame"""))
         act.setWhatsThis(self.tr(
             """<b>Step Out</b>"""
             """<p>Execute Python statements until leaving the current"""
             """ frame. If the statements are inside an <tt>import</tt>"""
             """ statement, a class constructor, or a method or function"""
             """ call then control is returned to the debugger after the"""
             """ current frame has been left.</p>"""
         ))
         act.triggered.connect(self.__stepOut)
         self.actions.append(act)
         act = E5Action(
             self.tr('Stop'),
             UI.PixmapCache.getIcon("stepQuit.png"),
             self.tr('&Stop'), Qt.Key_F10, 0,
             self.debugActGrp, 'dbg_stop')
         act.setStatusTip(self.tr('Stop debugging'))
         act.setWhatsThis(self.tr(
             """<b>Stop</b>"""
             """<p>Stop the running debugging session.</p>"""
         ))
         act.triggered.connect(self.__stepQuit)
         self.actions.append(act)
         self.dbgFilterAct = E5Action(
             self.tr('Variables Type Filter'),
             self.tr('Varia&bles Type Filter...'), 0, 0, self,
             'dbg_variables_filter')
         self.dbgFilterAct.setStatusTip(self.tr(
             'Configure variables type filter'))
         self.dbgFilterAct.setWhatsThis(self.tr(
             """<b>Variables Type Filter</b>"""
             """<p>Configure the variables type filter. Only variable types"""
             """ that are not selected are displayed in the global or local"""
             """ variables window during a debugging session.</p>"""
         ))
         self.dbgFilterAct.triggered.connect(
             self.__configureVariablesFilters)
         self.actions.append(self.dbgFilterAct)
         self.excFilterAct = E5Action(
             self.tr('Exceptions Filter'),
             self.tr('&Exceptions Filter...'), 0, 0, self,
             'dbg_exceptions_filter')
         self.excFilterAct.setStatusTip(self.tr(
             'Configure exceptions filter'))
         self.excFilterAct.setWhatsThis(self.tr(
             """<b>Exceptions Filter</b>"""
             """<p>Configure the exceptions filter. Only exception types"""
             """ that are listed are highlighted during a debugging"""
             """ session.</p><p>Please note, that all unhandled exceptions"""
             """ are highlighted indepent from the filter list.</p>"""
         ))
         self.excFilterAct.triggered.connect(
             self.__configureExceptionsFilter)
         self.actions.append(self.excFilterAct)
         self.excIgnoreFilterAct = E5Action(
             self.tr('Ignored Exceptions'),
             self.tr('&Ignored Exceptions...'), 0, 0,
             self, 'dbg_ignored_exceptions')
         self.excIgnoreFilterAct.setStatusTip(self.tr(
             'Configure ignored exceptions'))
         self.excIgnoreFilterAct.setWhatsThis(self.tr(
             """<b>Ignored Exceptions</b>"""
             """<p>Configure the ignored exceptions. Only exception types"""
             """ that are not listed are highlighted during a debugging"""
             """ session.</p><p>Please note, that unhandled exceptions"""
             """ cannot be ignored.</p>"""
         ))
         self.excIgnoreFilterAct.triggered.connect(
             self.__configureIgnoredExceptions)
         self.actions.append(self.excIgnoreFilterAct)
         self.dbgSetBpActGrp = createActionGroup(self)
         self.dbgToggleBpAct = E5Action(
             self.tr('Toggle Breakpoint'),
             UI.PixmapCache.getIcon("breakpointToggle.png"),
             self.tr('Toggle Breakpoint'),
             QKeySequence(self.tr("Shift+F11", "Debug|Toggle Breakpoint")),
 , self.dbgSetBpActGrp, 'dbg_toggle_breakpoint')
         self.dbgToggleBpAct.setStatusTip(self.tr('Toggle Breakpoint'))
         self.dbgToggleBpAct.setWhatsThis(self.tr(
             """<b>Toggle Breakpoint</b>"""
             """<p>Toggles a breakpoint at the current line of the"""
             """ current editor.</p>"""
         ))
         self.dbgToggleBpAct.triggered.connect(self.__toggleBreakpoint)
         self.actions.append(self.dbgToggleBpAct)
         self.dbgEditBpAct = E5Action(
             self.tr('Edit Breakpoint'),
             UI.PixmapCache.getIcon("cBreakpointToggle.png"),
             self.tr('Edit Breakpoint...'),
             QKeySequence(self.tr("Shift+F12", "Debug|Edit Breakpoint")), 0,
             self.dbgSetBpActGrp, 'dbg_edit_breakpoint')
         self.dbgEditBpAct.setStatusTip(self.tr('Edit Breakpoint'))
         self.dbgEditBpAct.setWhatsThis(self.tr(
             """<b>Edit Breakpoint</b>"""
             """<p>Opens a dialog to edit the breakpoints properties."""
             """ It works at the current line of the current editor.</p>"""
         ))
         self.dbgEditBpAct.triggered.connect(self.__editBreakpoint)
         self.actions.append(self.dbgEditBpAct)
         self.dbgNextBpAct = E5Action(
             self.tr('Next Breakpoint'),
             UI.PixmapCache.getIcon("breakpointNext.png"),
             self.tr('Next Breakpoint'),
             QKeySequence(
                 self.tr("Ctrl+Shift+PgDown", "Debug|Next Breakpoint")), 0,
             self.dbgSetBpActGrp, 'dbg_next_breakpoint')
         self.dbgNextBpAct.setStatusTip(self.tr('Next Breakpoint'))
         self.dbgNextBpAct.setWhatsThis(self.tr(
             """<b>Next Breakpoint</b>"""
             """<p>Go to next breakpoint of the current editor.</p>"""
         ))
         self.dbgNextBpAct.triggered.connect(self.__nextBreakpoint)
         self.actions.append(self.dbgNextBpAct)
         self.dbgPrevBpAct = E5Action(
             self.tr('Previous Breakpoint'),
             UI.PixmapCache.getIcon("breakpointPrevious.png"),
             self.tr('Previous Breakpoint'),
             QKeySequence(
                 self.tr("Ctrl+Shift+PgUp", "Debug|Previous Breakpoint")),
 , self.dbgSetBpActGrp, 'dbg_previous_breakpoint')
         self.dbgPrevBpAct.setStatusTip(self.tr('Previous Breakpoint'))
         self.dbgPrevBpAct.setWhatsThis(self.tr(
             """<b>Previous Breakpoint</b>"""
             """<p>Go to previous breakpoint of the current editor.</p>"""
         ))
         self.dbgPrevBpAct.triggered.connect(self.__previousBreakpoint)
         self.actions.append(self.dbgPrevBpAct)
         act = E5Action(
             self.tr('Clear Breakpoints'),
             self.tr('Clear Breakpoints'),
 , 0,
             self.dbgSetBpActGrp, 'dbg_clear_breakpoint')
         act.setStatusTip(self.tr('Clear Breakpoints'))
         act.setWhatsThis(self.tr(
             """<b>Clear Breakpoints</b>"""
             """<p>Clear breakpoints of all editors.</p>"""
         ))
         act.triggered.connect(self.__clearBreakpoints)
         self.actions.append(act)
         self.debugActGrp.setEnabled(False)
         self.dbgSetBpActGrp.setEnabled(False)
         self.runAct.setEnabled(False)
         self.runProjectAct.setEnabled(False)
         self.profileAct.setEnabled(False)
         self.profileProjectAct.setEnabled(False)
         self.coverageAct.setEnabled(False)
         self.coverageProjectAct.setEnabled(False)
         self.debugAct.setEnabled(False)
         self.debugProjectAct.setEnabled(False)
         self.restartAct.setEnabled(False)
         self.stopAct.setEnabled(False)
     def initMenus(self):
         """
         Public slot to initialize the project menu.
         @return the generated menu
         """
         dmenu = QMenu(self.tr('&Debug'), self.parent())
         dmenu.setTearOffEnabled(True)
         smenu = QMenu(self.tr('Sta&rt'), self.parent())
         smenu.setTearOffEnabled(True)
         self.breakpointsMenu = QMenu(self.tr('&Breakpoints'), dmenu)
         smenu.addAction(self.restartAct)
         smenu.addAction(self.stopAct)
         smenu.addSeparator()
         smenu.addAction(self.runAct)
         smenu.addAction(self.runProjectAct)
         smenu.addSeparator()
         smenu.addAction(self.debugAct)
         smenu.addAction(self.debugProjectAct)
         smenu.addSeparator()
         smenu.addAction(self.profileAct)
         smenu.addAction(self.profileProjectAct)
         smenu.addSeparator()
         smenu.addAction(self.coverageAct)
         smenu.addAction(self.coverageProjectAct)
         dmenu.addActions(self.debugActGrp.actions())
         dmenu.addSeparator()
         dmenu.addActions(self.dbgSetBpActGrp.actions())
         self.menuBreakpointsAct = dmenu.addMenu(self.breakpointsMenu)
         dmenu.addSeparator()
         dmenu.addAction(self.dbgFilterAct)
         dmenu.addAction(self.excFilterAct)
         dmenu.addAction(self.excIgnoreFilterAct)
         self.breakpointsMenu.aboutToShow.connect(self.__showBreakpointsMenu)
         self.breakpointsMenu.triggered.connect(self.__breakpointSelected)
         dmenu.aboutToShow.connect(self.__showDebugMenu)
         return smenu, dmenu
     def initToolbars(self, toolbarManager):
         """
         Public slot to initialize the debug toolbars.
         @param toolbarManager reference to a toolbar manager object
             (E5ToolBarManager)
         @return the generated toolbars (list of QToolBar)
         """
         starttb = QToolBar(self.tr("Start"), self.ui)
         starttb.setIconSize(UI.Config.ToolBarIconSize)
         starttb.setObjectName("StartToolbar")
         starttb.setToolTip(self.tr('Start'))
         starttb.addAction(self.restartAct)
         starttb.addAction(self.stopAct)
         starttb.addSeparator()
         starttb.addAction(self.runAct)
         starttb.addAction(self.runProjectAct)
         starttb.addSeparator()
         starttb.addAction(self.debugAct)
         starttb.addAction(self.debugProjectAct)
         debugtb = QToolBar(self.tr("Debug"), self.ui)
         debugtb.setIconSize(UI.Config.ToolBarIconSize)
         debugtb.setObjectName("DebugToolbar")
         debugtb.setToolTip(self.tr('Debug'))
         debugtb.addActions(self.debugActGrp.actions())
         debugtb.addSeparator()
         debugtb.addAction(self.dbgToggleBpAct)
         debugtb.addAction(self.dbgEditBpAct)
         debugtb.addAction(self.dbgNextBpAct)
         debugtb.addAction(self.dbgPrevBpAct)
         toolbarManager.addToolBar(starttb, starttb.windowTitle())
         toolbarManager.addToolBar(debugtb, debugtb.windowTitle())
         toolbarManager.addAction(self.profileAct, starttb.windowTitle())
         toolbarManager.addAction(self.profileProjectAct, starttb.windowTitle())
         toolbarManager.addAction(self.coverageAct, starttb.windowTitle())
         toolbarManager.addAction(self.coverageProjectAct,
                                  starttb.windowTitle())
         return [starttb, debugtb]
     def setArgvHistory(self, argsStr, clearHistories=False, history=None):
         """
         Public slot to initialize the argv history.
         @param argsStr the commandline arguments (string)
         @param clearHistories flag indicating, that the list should
             be cleared (boolean)
         @param history list of history entries to be set (list of strings)
         """
         if clearHistories:
             del self.argvHistory[1:]
         elif history is not None:
             self.argvHistory = history[:]
         else:
             if argsStr in self.argvHistory:
                 self.argvHistory.remove(argsStr)
             self.argvHistory.insert(0, argsStr)
     def setWdHistory(self, wdStr, clearHistories=False, history=None):
         """
         Public slot to initialize the wd history.
         @param wdStr the working directory (string)
         @param clearHistories flag indicating, that the list should
             be cleared (boolean)
         @param history list of history entries to be set (list of strings)
         """
         if clearHistories:
             del self.wdHistory[1:]
         elif history is not None:
             self.wdHistory = history[:]
         else:
             if wdStr in self.wdHistory:
                 self.wdHistory.remove(wdStr)
             self.wdHistory.insert(0, wdStr)
     def setEnvHistory(self, envStr, clearHistories=False, history=None):
         """
         Public slot to initialize the env history.
         @param envStr the environment settings (string)
         @param clearHistories flag indicating, that the list should
             be cleared (boolean)
         @param history list of history entries to be set (list of strings)
         """
         if clearHistories:
             del self.envHistory[1:]
         elif history is not None:
             self.envHistory = history[:]
         else:
             if envStr in self.envHistory:
                 self.envHistory.remove(envStr)
             self.envHistory.insert(0, envStr)
     def setExceptionReporting(self, exceptions):
         """
         Public slot to initialize the exception reporting flag.
         @param exceptions flag indicating exception reporting status (boolean)
         """
         self.exceptions = exceptions
     def setExcList(self, excList):
         """
         Public slot to initialize the exceptions type list.
         @param excList list of exception types (list of strings)
         """
         self.excList = excList[:]   # keep a copy
     def setExcIgnoreList(self, excIgnoreList):
         """
         Public slot to initialize the ignored exceptions type list.
         @param excIgnoreList list of ignored exception types (list of strings)
         """
         self.excIgnoreList = excIgnoreList[:]   # keep a copy
     def setAutoClearShell(self, autoClearShell):
         """
         Public slot to initialize the autoClearShell flag.
         @param autoClearShell flag indicating, that the interpreter window
             should be cleared (boolean)
         """
         self.autoClearShell = autoClearShell
     def setTracePython(self, tracePython):
         """
         Public slot to initialize the trace Python flag.
         @param tracePython flag indicating if the Python library should be
             traced as well (boolean)
         """
         self.tracePython = tracePython
     def setAutoContinue(self, autoContinue):
         """
         Public slot to initialize the autoContinue flag.
         @param autoContinue flag indicating, that the debugger should not
             stop at the first executable line (boolean)
         """
         self.autoContinue = autoContinue
     def __editorOpened(self, fn):
         """
         Private slot to handle the editorOpened signal.
         @param fn filename of the opened editor
         """
         self.editorOpen = True
         if fn:
             editor = self.viewmanager.getOpenEditor(fn)
         else:
             editor = None
         self.__checkActions(editor)
     def __lastEditorClosed(self):
         """
         Private slot to handle the closeProgram signal.
         """
         self.editorOpen = False
         self.debugAct.setEnabled(False)
         self.runAct.setEnabled(False)
         self.profileAct.setEnabled(False)
         self.coverageAct.setEnabled(False)
         self.debugActGrp.setEnabled(False)
         self.dbgSetBpActGrp.setEnabled(False)
         self.lastAction = -1
         if not self.projectOpen:
             self.restartAct.setEnabled(False)
             self.lastDebuggedFile = None
             self.lastStartAction = 0
             self.clientType = ""
     def __checkActions(self, editor):
         """
         Private slot to check some actions for their enable/disable status.
         @param editor editor window
         """
         if editor:
             fn = editor.getFileName()
         else:
             fn = None
         cap = 0
         if fn:
             for language in self.debugServer.getSupportedLanguages():
                 exts = self.debugServer.getExtensions(language)
                 if fn.endswith(exts):
                     cap = self.debugServer.getClientCapabilities(language)
                     break
             else:
                 if editor.isPy2File():
                     cap = self.debugServer.getClientCapabilities('Python2')
                 elif editor.isPy3File():
                     cap = self.debugServer.getClientCapabilities('Python3')
                 elif editor.isRubyFile():
                     cap = self.debugServer.getClientCapabilities('Ruby')
             if not self.passive:
                 self.runAct.setEnabled(cap & HasInterpreter)
                 self.coverageAct.setEnabled(cap & HasCoverage)
                 self.profileAct.setEnabled(cap & HasProfiler)
                 self.debugAct.setEnabled(cap & HasDebugger)
             self.dbgSetBpActGrp.setEnabled(cap & HasDebugger)
             if editor.curLineHasBreakpoint():
                 self.dbgEditBpAct.setEnabled(True)
             else:
                 self.dbgEditBpAct.setEnabled(False)
             if editor.hasBreakpoints():
                 self.dbgNextBpAct.setEnabled(True)
                 self.dbgPrevBpAct.setEnabled(True)
             else:
                 self.dbgNextBpAct.setEnabled(False)
                 self.dbgPrevBpAct.setEnabled(False)
         else:
             self.runAct.setEnabled(False)
             self.coverageAct.setEnabled(False)
             self.profileAct.setEnabled(False)
             self.debugAct.setEnabled(False)
             self.dbgSetBpActGrp.setEnabled(False)
     def __cursorChanged(self, editor):
         """
         Private slot handling the cursorChanged signal of the viewmanager.
         @param editor editor window
         """
         if editor is None:
             return
         if editor.isPyFile() or editor.isRubyFile():
             if editor.curLineHasBreakpoint():
                 self.dbgEditBpAct.setEnabled(True)
             else:
                 self.dbgEditBpAct.setEnabled(False)
             if editor.hasBreakpoints():
                 self.dbgNextBpAct.setEnabled(True)
                 self.dbgPrevBpAct.setEnabled(True)
             else:
                 self.dbgNextBpAct.setEnabled(False)
                 self.dbgPrevBpAct.setEnabled(False)
     def __projectOpened(self):
         """
         Private slot to handle the projectOpened signal.
         """
         self.projectOpen = True
         cap = self.debugServer.getClientCapabilities(
             self.project.getProjectLanguage())
         if not self.passive:
             self.debugProjectAct.setEnabled(cap & HasDebugger)
             self.runProjectAct.setEnabled(cap & HasInterpreter)
             self.profileProjectAct.setEnabled(cap & HasProfiler)
             self.coverageProjectAct.setEnabled(cap & HasCoverage)
     def __projectClosed(self):
         """
         Private slot to handle the projectClosed signal.
         """
         self.projectOpen = False
         self.runProjectAct.setEnabled(False)
         self.profileProjectAct.setEnabled(False)
         self.coverageProjectAct.setEnabled(False)
         self.debugProjectAct.setEnabled(False)
         if not self.editorOpen:
             self.restartAct.setEnabled(False)
             self.lastDebuggedFile = None
             self.lastStartAction = 0
             self.clientType = ""
     def clearHistories(self):
         """
         Public method to clear the various debug histories.
         """
         self.argvHistory = []
         self.wdHistory = []
         self.envHistory = []
         Preferences.Prefs.settings.setValue(
             'DebugInfo/ArgumentsHistory', self.argvHistory)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/WorkingDirectoryHistory', self.wdHistory)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/EnvironmentHistory', self.envHistory)
     def shutdown(self):
         """
         Public method to perform shutdown actions.
         """
         # Just save the 10 most recent entries
         del self.argvHistory[10:]
         del self.wdHistory[10:]
         del self.envHistory[10:]
         Preferences.Prefs.settings.setValue(
             'DebugInfo/VirtualEnvironment', self.lastUsedVenvName)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/ArgumentsHistory', self.argvHistory)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/WorkingDirectoryHistory', self.wdHistory)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/EnvironmentHistory', self.envHistory)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/Exceptions', self.excList)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/IgnoredExceptions', self.excIgnoreList)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/ReportExceptions', self.exceptions)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/AutoClearShell', self.autoClearShell)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/TracePython', self.tracePython)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/AutoContinue', self.autoContinue)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/ForkAutomatically', self.forkAutomatically)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/ForkIntoChild', self.forkIntoChild)
         Preferences.Prefs.settings.setValue(
             'DebugInfo/EnableMultiprocess', self.enableMultiprocess)
     def shutdownServer(self):
         """
         Public method to shut down the debug server.
         This is needed to cleanly close the sockets on Win OS.
         @return always true
         """
         self.debugServer.shutdownServer()
         return True
     def __resetUI(self):
         """
         Private slot to reset the user interface.
         """
         self.lastAction = -1
         self.debugActGrp.setEnabled(False)
         if not self.passive:
             if self.editorOpen:
                 editor = self.viewmanager.activeWindow()
             else:
                 editor = None
             self.__checkActions(editor)
             self.debugProjectAct.setEnabled(self.projectOpen)
             self.runProjectAct.setEnabled(self.projectOpen)
             self.profileProjectAct.setEnabled(self.projectOpen)
             self.coverageProjectAct.setEnabled(self.projectOpen)
             if (
                 self.lastDebuggedFile is not None and
                 (self.editorOpen or self.projectOpen)
             ):
                 self.restartAct.setEnabled(True)
             else:
                 self.restartAct.setEnabled(False)
             self.stopAct.setEnabled(False)
         self.resetUI.emit()
     def __clientLine(self, fn, line, debuggerId, forStack):
         """
         Private method to handle a change to the current line.
         @param fn filename
         @type str
         @param line linenumber
         @type int
         @param debuggerId ID of the debugger backend
         @type str
         @param forStack flag indicating this is for a stack dump
         @type bool
         """
         self.ui.raise_()
         self.ui.activateWindow()
         if self.ui.getViewProfile() != "debug":
             self.ui.setDebugProfile()
         self.viewmanager.setFileLine(fn, line)
         if not forStack:
             self.__getThreadList()
             self.__getClientVariables(debuggerId)
         self.debugActGrp.setEnabled(True)
     @pyqtSlot(int, str, bool)
     def __clientExit(self, status, message, quiet):
         """
         Private method to handle the debugged program terminating.
         @param status exit code of the debugged program
         @type int
         @param message exit message of the debugged program
         @type str
         @param quiet flag indicating to suppress exit info display
         @type bool
         """
         if not quiet:
             if (
                 not Preferences.getDebugger("SuppressClientExit") or
                 status != 0
             ):
                 if message:
                     info = self.tr("<p>Message: {0}</p>").format(
                         Utilities.html_uencode(message))
                 else:
                     info = ""
                 if self.ui.currentProg is None:
                     E5MessageBox.information(
                         self.ui, Program,
                         self.tr('<p>The program has terminated with an exit'
                                 ' status of {0}.</p>{1}').format(status, info))
                 else:
                     E5MessageBox.information(
                         self.ui, Program,
                         self.tr('<p><b>{0}</b> has terminated with an exit'
                                 ' status of {1}.</p>{2}')
                             .format(Utilities.normabspath(self.ui.currentProg),
                                     status, info))
             else:
                 if message:
                     info = self.tr("Message: {0}").format(
                         Utilities.html_uencode(message))
                 else:
                     info = ""
                 if self.ui.notificationsEnabled():
                     if self.ui.currentProg is None:
                         msg = self.tr(
                             'The program has terminated with an exit status of'
                             ' {0}.\n{1}').format(status, info)
                     else:
                         msg = self.tr(
                             '"{0}" has terminated with an exit status of'
                             ' {1}.\n{2}').format(
                             os.path.basename(self.ui.currentProg), status,
                             info)
                     self.ui.showNotification(
                         UI.PixmapCache.getPixmap("debug48.png"),
                         self.tr("Program terminated"), msg)
                 else:
                     if self.ui.currentProg is None:
                         self.appendStdout.emit(self.tr(
                             'The program has terminated with an exit status'
                             ' of {0}.\n{1}\n').format(status, info))
                     else:
                         self.appendStdout.emit(self.tr(
                             '"{0}" has terminated with an exit status of'
                             ' {1}.\n{2}\n').format(
                             Utilities.normabspath(self.ui.currentProg), status,
                             info))
 




b6674724612a
Continued with the multiprocess debugger.

Detlev Offenbach <detlev@die-offenbachs.de>
parents: 
7389

Mercurial Repositories > eric / annotate

eric6/Debugger/DebugUI.py@1413bfe73d41 (annotated)

eric6/Debugger/DebugUI.py