private static void removeJSBreakpointsInDartFiles(final Project project) { final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager(); final Collection<XBreakpoint<?>> toRemove = new ArrayList<XBreakpoint<?>>(); for (XBreakpoint<?> breakpoint : breakpointManager.getAllBreakpoints()) { final XSourcePosition position = breakpoint.getSourcePosition(); if (position != null && position.getFile().getFileType() == DartFileType.INSTANCE && !(breakpoint.getType() instanceof DartLineBreakpointType)) { toRemove.add(breakpoint); } } if (!toRemove.isEmpty()) { ApplicationManager.getApplication() .runWriteAction( new Runnable() { public void run() { for (XBreakpoint<?> breakpoint : toRemove) { breakpointManager.removeBreakpoint(breakpoint); } } }); } }
public void init() { XBreakpointManager manager = XDebuggerManager.getInstance(myProject).getBreakpointManager(); manager.addBreakpointListener( new XBreakpointListener() { @Override public void breakpointAdded(@NotNull XBreakpoint xBreakpoint) { if (isJavaType(xBreakpoint)) { onBreakpointAdded(xBreakpoint); } } @Override public void breakpointRemoved(@NotNull XBreakpoint xBreakpoint) { onBreakpointRemoved(xBreakpoint); } @Override public void breakpointChanged(@NotNull XBreakpoint xBreakpoint) { Breakpoint breakpoint = myBreakpoints.get(xBreakpoint); if (breakpoint != null) { fireBreakpointChanged(breakpoint); } } }); }
protected void stepOver() { XDebugSession currentSession = XDebuggerManager.getInstance(getProject()).getCurrentSession(); Assert.assertTrue(currentSession.isSuspended()); Assert.assertEquals(0, myPausedSemaphore.availablePermits()); currentSession.stepOver(false); }
protected void smartStepInto(String funcName) { XDebugSession currentSession = XDebuggerManager.getInstance(getProject()).getCurrentSession(); Assert.assertTrue(currentSession.isSuspended()); Assert.assertEquals(0, myPausedSemaphore.availablePermits()); myDebugProcess.startSmartStepInto(funcName); }
@Override public void initComponent() { super.init(); myDebuggerManager = DebuggerManagerEx.getInstanceEx(myProject); XDebuggerManager.getInstance(myProject) .getBreakpointManager() .addBreakpointListener(myBreakpointListener); }
@Override public void disposeComponent() { super.dispose(); XDebuggerManager.getInstance(myProject) .getBreakpointManager() .removeBreakpointListener(myBreakpointListener); myDebuggerManager = null; }
protected void runToLine(int line) throws InvocationTargetException, InterruptedException { XDebugSession currentSession = XDebuggerManager.getInstance(getProject()).getCurrentSession(); XSourcePosition position = currentSession.getCurrentPosition(); currentSession.runToPosition( XDebuggerUtil.getInstance().createPosition(position.getFile(), line), false); waitForPause(); }
protected void stepIntoMyCode() { XDebugSession currentSession = XDebuggerManager.getInstance(getProject()).getCurrentSession(); Assert.assertTrue(currentSession.isSuspended()); Assert.assertEquals(0, myPausedSemaphore.availablePermits()); PyDebugProcess debugProcess = (PyDebugProcess) currentSession.getDebugProcess(); debugProcess.startStepIntoMyCode(); }
@Nullable private static DebugProcessImpl getCurrentDebugProcess(@Nullable Project project) { if (project != null) { XDebugSession session = XDebuggerManager.getInstance(project).getCurrentSession(); if (session != null) { XDebugProcess process = session.getDebugProcess(); if (process instanceof JavaDebugProcess) { return ((JavaDebugProcess) process).getDebuggerSession().getProcess(); } } } return null; }
private XDebugSession connectToDebugger() throws ExecutionException { final ServerSocket serverSocket = PythonCommandLineState.createServerSocket(); final XDebugSession session = XDebuggerManager.getInstance(getProject()) .startSessionAndShowTab( "Python Console Debugger", PythonIcons.Python.Python, null, true, new XDebugProcessStarter() { @NotNull public XDebugProcess start(@NotNull final XDebugSession session) { PythonDebugLanguageConsoleView debugConsoleView = new PythonDebugLanguageConsoleView(getProject(), mySdk); PyConsoleDebugProcessHandler consoleDebugProcessHandler = new PyConsoleDebugProcessHandler(myProcessHandler); PyConsoleDebugProcess consoleDebugProcess = new PyConsoleDebugProcess( session, serverSocket, debugConsoleView, consoleDebugProcessHandler); PythonDebugConsoleCommunication communication = PyDebugRunner.initDebugConsoleView( getProject(), consoleDebugProcess, debugConsoleView, consoleDebugProcessHandler); myPydevConsoleCommunication.setDebugCommunication(communication); debugConsoleView.attachToProcess(consoleDebugProcessHandler); consoleDebugProcess.waitForNextConnection(); try { consoleDebugProcess.connect(myPydevConsoleCommunication); } catch (Exception e) { LOG.error(e); // TODO } myProcessHandler.notifyTextAvailable( "\nDebugger connected.\n", ProcessOutputTypes.STDERR); return consoleDebugProcess; } }); return session; }
public boolean isEnabled(@NotNull final Project project, final AnActionEvent event) { XLineBreakpointType<?>[] breakpointTypes = XDebuggerUtil.getInstance().getLineBreakpointTypes(); final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager(); for (XSourcePosition position : XDebuggerUtilImpl.getAllCaretsPositions(project, event.getDataContext())) { for (XLineBreakpointType<?> breakpointType : breakpointTypes) { final VirtualFile file = position.getFile(); final int line = position.getLine(); if (breakpointType.canPutAt(file, line, project) || breakpointManager.findBreakpointAtLine(breakpointType, file, line) != null) { return true; } } } return false; }
protected DebuggerSession attachVirtualMachine( RunProfileState state, ExecutionEnvironment environment, RemoteConnection remoteConnection, boolean pollConnection) throws ExecutionException { final DebuggerSession debuggerSession = DebuggerManagerEx.getInstanceEx(myProject) .attachVirtualMachine( new DefaultDebugEnvironment(environment, state, remoteConnection, pollConnection)); XDebuggerManager.getInstance(myProject) .startSession( environment, new XDebugProcessStarter() { @Override @NotNull public XDebugProcess start(@NotNull XDebugSession session) { return JavaDebugProcess.create(session, debuggerSession); } }); return debuggerSession; }
private void updateGutter() { if (myVisible) { if (isValid()) { final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(myProject).getBreakpointManager(); breakpointManager.updateBreakpointPresentation( (XLineBreakpoint) myXBreakpoint, getIcon(), null); } // RangeHighlighter highlighter = myHighlighter; // if (highlighter != null && highlighter.isValid() && isValid()) { // AppUIUtil.invokeLaterIfProjectAlive(myProject, new Runnable() { // @Override // public void run() { // if (isValid()) { // setupGutterRenderer(myHighlighter); // } // } // }); // } // else { // DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().removeBreakpoint(this); // } } }
public void testXDebugger() throws Exception { final WorkingContextManager manager = getContextManager(); final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(getProject()).getBreakpointManager(); ApplicationManager.getApplication() .runWriteAction( new Runnable() { public void run() { XLineBreakpointImpl<XBreakpointProperties> breakpoint = (XLineBreakpointImpl<XBreakpointProperties>) breakpointManager.addLineBreakpoint( new XsltBreakpointType(), "foo", 0, null); final String name = "foo"; manager.saveContext(name, null); breakpointManager.removeBreakpoint(breakpoint); } }); manager.loadContext("foo"); XBreakpoint<?>[] breakpoints = breakpointManager.getAllBreakpoints(); assertEquals(1, breakpoints.length); manager.clearContext(); }
private XBreakpointManagerImpl getBreakpointManager() { return (XBreakpointManagerImpl) XDebuggerManager.getInstance(myProject).getBreakpointManager(); }
private XBreakpointManager getXBreakpointManager() { return XDebuggerManager.getInstance(myProject).getBreakpointManager(); }
/** * Toggle line breakpoint with editor support: - unfolds folded block on the line - if folded, * checks if line breakpoints could be toggled inside folded text */ @NotNull public static Promise toggleLineBreakpoint( @NotNull Project project, @NotNull XSourcePosition position, @Nullable Editor editor, boolean temporary, boolean moveCarret) { int lineStart = position.getLine(); VirtualFile file = position.getFile(); // for folded text check each line and find out type with the biggest priority int linesEnd = lineStart; if (editor != null) { FoldRegion region = FoldingUtil.findFoldRegionStartingAtLine(editor, lineStart); if (region != null && !region.isExpanded()) { linesEnd = region.getDocument().getLineNumber(region.getEndOffset()); } } final XBreakpointManager breakpointManager = XDebuggerManager.getInstance(project).getBreakpointManager(); XLineBreakpointType<?>[] lineTypes = XDebuggerUtil.getInstance().getLineBreakpointTypes(); XLineBreakpointType<?> typeWinner = null; int lineWinner = -1; for (int line = lineStart; line <= linesEnd; line++) { int maxPriority = 0; for (XLineBreakpointType<?> type : lineTypes) { maxPriority = Math.max(maxPriority, type.getPriority()); final XLineBreakpoint<? extends XBreakpointProperties> breakpoint = breakpointManager.findBreakpointAtLine(type, file, line); if (breakpoint != null && temporary && !breakpoint.isTemporary()) { breakpoint.setTemporary(true); } else if (type.canPutAt(file, line, project) || breakpoint != null) { if (typeWinner == null || type.getPriority() > typeWinner.getPriority()) { typeWinner = type; lineWinner = line; } } } // already found max priority type - stop if (typeWinner != null && typeWinner.getPriority() == maxPriority) { break; } } if (typeWinner != null) { XSourcePosition winPosition = (lineStart == lineWinner) ? position : XSourcePositionImpl.create(file, lineWinner); if (winPosition != null) { Promise<XLineBreakpoint> res = XDebuggerUtilImpl.toggleAndReturnLineBreakpoint( project, typeWinner, winPosition, temporary, editor); if (editor != null && lineStart != lineWinner) { int offset = editor.getDocument().getLineStartOffset(lineWinner); ExpandRegionAction.expandRegionAtOffset(project, editor, offset); if (moveCarret) { editor.getCaretModel().moveToOffset(offset); } } return res; } } return PromiseKt.rejectedPromise(); }
@Nullable @Override public EditorNotificationPanel createNotificationPanel( @NotNull VirtualFile file, @NotNull FileEditor fileEditor) { XDebugSession session = XDebuggerManager.getInstance(myProject).getCurrentSession(); if (session == null) { FILE_PROCESSED_KEY.set(file, null); return null; } XSourcePosition position = session.getCurrentPosition(); if (position == null || !file.equals(position.getFile())) { FILE_PROCESSED_KEY.set(file, null); return null; } if (file.getFileType() == JavaClassFileType.INSTANCE) return null; final PsiFile psiFile = PsiManager.getInstance(myProject).findFile(file); if (psiFile == null) return null; if (!(psiFile instanceof PsiJavaFile)) return null; PsiClass[] classes = ((PsiJavaFile) psiFile).getClasses(); if (classes.length == 0) return null; PsiClass baseClass = classes[0]; String name = baseClass.getQualifiedName(); if (name == null) return null; if (DumbService.getInstance(myProject).isDumb()) return null; ArrayList<PsiClass> alts = ContainerUtil.newArrayList( JavaPsiFacade.getInstance(myProject) .findClasses(name, GlobalSearchScope.allScope(myProject))); ContainerUtil.removeDuplicates(alts); FILE_PROCESSED_KEY.set(file, true); if (alts.size() > 1) { for (PsiClass cls : alts) { if (cls.equals(baseClass) || cls.getNavigationElement().equals(baseClass)) { alts.remove(cls); break; } } alts.add(0, baseClass); ComboBoxClassElement[] elems = ContainerUtil.map2Array( alts, ComboBoxClassElement.class, new Function<PsiClass, ComboBoxClassElement>() { @Override public ComboBoxClassElement fun(PsiClass psiClass) { return new ComboBoxClassElement(psiClass); } }); return new AlternativeSourceNotificationPanel(elems, baseClass, myProject, file); } return null; }
@Override public AbstractDebuggerSession getCurrentSession(@NotNull Project project) { return XDebuggerManager.getInstance(project).getCurrentSession(); }
protected DebuggerSession createLocalSession(final JavaParameters javaParameters) throws ExecutionException, InterruptedException { createBreakpoints(javaParameters.getMainClass()); DebuggerSettings.getInstance().DEBUGGER_TRANSPORT = DebuggerSettings.SOCKET_TRANSPORT; GenericDebuggerRunnerSettings debuggerRunnerSettings = new GenericDebuggerRunnerSettings(); debuggerRunnerSettings.LOCAL = true; final RemoteConnection debugParameters = DebuggerManagerImpl.createDebugParameters(javaParameters, debuggerRunnerSettings, false); ExecutionEnvironment environment = new ExecutionEnvironmentBuilder(myProject, DefaultDebugExecutor.getDebugExecutorInstance()) .runnerSettings(debuggerRunnerSettings) .runProfile(new MockConfiguration()) .build(); final JavaCommandLineState javaCommandLineState = new JavaCommandLineState(environment) { @Override protected JavaParameters createJavaParameters() { return javaParameters; } @Override protected GeneralCommandLine createCommandLine() throws ExecutionException { return CommandLineBuilder.createFromJavaParameters(getJavaParameters()); } }; ApplicationManager.getApplication() .invokeAndWait( () -> { try { myDebuggerSession = DebuggerManagerEx.getInstanceEx(myProject) .attachVirtualMachine( new DefaultDebugEnvironment( new ExecutionEnvironmentBuilder( myProject, DefaultDebugExecutor.getDebugExecutorInstance()) .runProfile(new MockConfiguration()) .build(), javaCommandLineState, debugParameters, false)); XDebuggerManager.getInstance(myProject) .startSession( javaCommandLineState.getEnvironment(), new XDebugProcessStarter() { @Override @NotNull public XDebugProcess start(@NotNull XDebugSession session) { return JavaDebugProcess.create(session, myDebuggerSession); } }); } catch (ExecutionException e) { LOG.error(e); } }); myDebugProcess = myDebuggerSession.getProcess(); myDebugProcess.addProcessListener( new ProcessAdapter() { @Override public void onTextAvailable(ProcessEvent event, Key outputType) { print(event.getText(), outputType); } }); assertNotNull(myDebuggerSession); assertNotNull(myDebugProcess); return myDebuggerSession; }