diff --git a/java/debugger/impl/src/com/intellij/debugger/DebugEnvironment.java b/java/debugger/impl/src/com/intellij/debugger/DebugEnvironment.java new file mode 100644 index 000000000000..68486c82b847 --- /dev/null +++ b/java/debugger/impl/src/com/intellij/debugger/DebugEnvironment.java @@ -0,0 +1,57 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.debugger; + +import com.intellij.diagnostic.logging.LogFilesManager; +import com.intellij.execution.ExecutionException; +import com.intellij.execution.ExecutionResult; +import com.intellij.execution.configurations.RemoteConnection; +import com.intellij.execution.ui.RunContentDescriptor; +import com.intellij.openapi.actionSystem.DefaultActionGroup; +import com.intellij.psi.search.GlobalSearchScope; +import org.jetbrains.annotations.Nullable; + +import javax.swing.*; + +/** + * Created by IntelliJ IDEA. + * User: michael.golubev + */ +public interface DebugEnvironment { + + @Nullable + ExecutionResult createExecutionResult() throws ExecutionException; + + GlobalSearchScope getSearchScope(); + + boolean isRemote(); + + @Nullable + RunContentDescriptor getReuseContent(); + + RemoteConnection getRemoteConnection(); + + boolean isPollConnection(); + + String getSessionName(); + + @Nullable + Icon getIcon(); + + void initContent(RunContentDescriptor content, + LogFilesManager logFilesManager, + DefaultActionGroup group); +} diff --git a/java/debugger/impl/src/com/intellij/debugger/DebuggerManagerEx.java b/java/debugger/impl/src/com/intellij/debugger/DebuggerManagerEx.java index 834757b57b84..0384e6e68b1f 100644 --- a/java/debugger/impl/src/com/intellij/debugger/DebuggerManagerEx.java +++ b/java/debugger/impl/src/com/intellij/debugger/DebuggerManagerEx.java @@ -54,4 +54,5 @@ public abstract class DebuggerManagerEx extends DebuggerManager { boolean pollConnection ) throws ExecutionException; + public abstract DebuggerSession attachVirtualMachine(DebugEnvironment environment) throws ExecutionException; } diff --git a/java/debugger/impl/src/com/intellij/debugger/DefaultDebugEnvironment.java b/java/debugger/impl/src/com/intellij/debugger/DefaultDebugEnvironment.java new file mode 100644 index 000000000000..639f1802e48e --- /dev/null +++ b/java/debugger/impl/src/com/intellij/debugger/DefaultDebugEnvironment.java @@ -0,0 +1,210 @@ +/* + * Copyright 2000-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.debugger; + +import com.intellij.diagnostic.logging.LogFilesManager; +import com.intellij.diagnostic.logging.OutputFileUtil; +import com.intellij.execution.ExecutionException; +import com.intellij.execution.ExecutionResult; +import com.intellij.execution.Executor; +import com.intellij.execution.configurations.*; +import com.intellij.execution.filters.ExceptionFilters; +import com.intellij.execution.filters.Filter; +import com.intellij.execution.filters.TextConsoleBuilder; +import com.intellij.execution.process.ProcessHandler; +import com.intellij.execution.runners.ExecutionEnvironment; +import com.intellij.execution.runners.ProgramRunner; +import com.intellij.execution.runners.RestartAction; +import com.intellij.execution.ui.RunContentDescriptor; +import com.intellij.execution.ui.actions.CloseAction; +import com.intellij.ide.actions.ContextHelpAction; +import com.intellij.openapi.actionSystem.Constraints; +import com.intellij.openapi.actionSystem.DefaultActionGroup; +import com.intellij.openapi.module.Module; +import com.intellij.openapi.project.Project; +import com.intellij.psi.search.GlobalSearchScope; +import com.intellij.xdebugger.impl.ui.XDebuggerUIConstants; +import org.jetbrains.annotations.Nullable; + +import javax.swing.*; +import java.util.List; + +/** + * Created by IntelliJ IDEA. + * User: michael.golubev + */ +public class DefaultDebugEnvironment implements DebugEnvironment { + + private final GlobalSearchScope mySearchScope; + private final Project myProject; + private final Executor myExecutor; + private final ProgramRunner myRunner; + @Nullable private final ExecutionEnvironment myEnvironment; + private RunProfileState myState; + @Nullable private final RunContentDescriptor myReuseContent; + private final RemoteConnection myRemoteConnection; + private final boolean myPollConnection; + private final RunProfile myRunProfile; + + public DefaultDebugEnvironment(Project project, + Executor executor, + ProgramRunner runner, + ExecutionEnvironment environment, + RunProfileState state, + @Nullable RunContentDescriptor reuseContent, + RemoteConnection remoteConnection, + boolean pollConnection) { + this(project, + executor, + runner, + environment, + environment.getRunProfile(), + state, + reuseContent, + remoteConnection, + pollConnection); + } + + public DefaultDebugEnvironment(Project project, + Executor executor, + ProgramRunner runner, + RunProfile runProfile, + RunProfileState state, + @Nullable RunContentDescriptor reuseContent, + RemoteConnection remoteConnection, + boolean pollConnection) { + this(project, + executor, + runner, + null, + runProfile, + state, + reuseContent, + remoteConnection, + pollConnection); + } + + private DefaultDebugEnvironment(Project project, + Executor executor, + ProgramRunner runner, + @Nullable ExecutionEnvironment environment, + RunProfile runProfile, + RunProfileState state, + @Nullable RunContentDescriptor reuseContent, + RemoteConnection remoteConnection, + boolean pollConnection) { + myProject = project; + myExecutor = executor; + myRunner = runner; + myEnvironment = environment; + myRunProfile = runProfile; + myState = state; + myReuseContent = reuseContent; + myRemoteConnection = remoteConnection; + myPollConnection = pollConnection; + + Module[] modules = null; + if (myRunProfile instanceof ModuleRunProfile) { + modules = ((ModuleRunProfile)myRunProfile).getModules(); + } + if (modules == null || modules.length == 0) { + mySearchScope = GlobalSearchScope.allScope(project); + } + else { + GlobalSearchScope scope = GlobalSearchScope.moduleRuntimeScope(modules[0], true); + for (int idx = 1; idx < modules.length; idx++) { + Module module = modules[idx]; + scope = scope.uniteWith(GlobalSearchScope.moduleRuntimeScope(module, true)); + } + mySearchScope = scope; + } + } + + @Override + public ExecutionResult createExecutionResult() throws ExecutionException { + if (myState instanceof CommandLineState) { + final TextConsoleBuilder consoleBuilder = ((CommandLineState)myState).getConsoleBuilder(); + if (consoleBuilder != null) { + List filters = ExceptionFilters.getFilters(mySearchScope); + for (Filter filter : filters) { + consoleBuilder.addFilter(filter); + } + } + } + return myState.execute(myExecutor, myRunner); + } + + @Override + public GlobalSearchScope getSearchScope() { + return mySearchScope; + } + + @Override + public boolean isRemote() { + return myState instanceof RemoteState; + } + + @Nullable + @Override + public RunContentDescriptor getReuseContent() { + return myReuseContent; + } + + @Override + public RemoteConnection getRemoteConnection() { + return myRemoteConnection; + } + + @Override + public boolean isPollConnection() { + return myPollConnection; + } + + @Override + public String getSessionName() { + return myRunProfile.getName(); + } + + @Override + public Icon getIcon() { + return myRunProfile.getIcon(); + } + + @Override + public void initContent(RunContentDescriptor content, LogFilesManager logFilesManager, DefaultActionGroup actionGroup) { + ProcessHandler processHandler = content.getProcessHandler(); + if (myRunProfile instanceof RunConfigurationBase) { + RunConfigurationBase runConfiguration = (RunConfigurationBase)myRunProfile; + + logFilesManager.registerFileMatcher(runConfiguration); + + logFilesManager.initLogConsoles(runConfiguration, processHandler); + OutputFileUtil.attachDumpListener(runConfiguration, processHandler, content.getExecutionConsole()); + } + + RestartAction restartAction = new RestartAction(myExecutor, + myRunner, + processHandler, + XDebuggerUIConstants.DEBUG_AGAIN_ICON, + content, + myEnvironment); + actionGroup.add(restartAction, Constraints.FIRST); + restartAction.registerShortcut(content.getComponent()); + + actionGroup.add(new CloseAction(myExecutor, content, myProject)); + actionGroup.add(new ContextHelpAction(myExecutor.getHelpId())); + } +} diff --git a/java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java b/java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java index 439311c6fb34..5e6abb13560b 100644 --- a/java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java +++ b/java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java @@ -16,10 +16,7 @@ package com.intellij.debugger.engine; import com.intellij.Patches; -import com.intellij.debugger.DebuggerBundle; -import com.intellij.debugger.DebuggerInvocationUtil; -import com.intellij.debugger.DebuggerManagerEx; -import com.intellij.debugger.PositionManager; +import com.intellij.debugger.*; import com.intellij.debugger.actions.DebuggerActions; import com.intellij.debugger.apiAdapters.ConnectionServiceWrapper; import com.intellij.debugger.apiAdapters.TransportServiceWrapper; @@ -764,7 +761,7 @@ public abstract class DebugProcessImpl implements DebugProcess { protected void closeProcess(boolean closedByUser) { DebuggerManagerThreadImpl.assertIsManagerThread(); - + if (myState.compareAndSet(STATE_INITIAL, STATE_DETACHING) || myState.compareAndSet(STATE_ATTACHED, STATE_DETACHING)) { try { getManagerThread().close(); @@ -925,7 +922,7 @@ public abstract class DebugProcessImpl implements DebugProcess { myEvaluationDispatcher.getMulticaster().evaluationStarted(suspendContext); beforeMethodInvocation(suspendContext, method); - + Object resumeData = null; try { for (final SuspendContextImpl suspendingContext : suspendingContexts) { @@ -1638,28 +1635,33 @@ public abstract class DebugProcessImpl implements DebugProcess { final RunProfileState state, final RemoteConnection remoteConnection, boolean pollConnection) throws ExecutionException { + return attachVirtualMachine(new DefaultDebugEnvironment(myProject, + executor, + runner, + state.getRunnerSettings().getRunProfile(), + state, + null, + remoteConnection, + pollConnection), + session); + } + + @Nullable + public ExecutionResult attachVirtualMachine(final DebugEnvironment environment, + final DebuggerSession session) throws ExecutionException { mySession = session; myWaitFor.down(); ApplicationManager.getApplication().assertIsDispatchThread(); LOG.assertTrue(isInInitialState()); - myConnection = remoteConnection; + myConnection = environment.getRemoteConnection(); - createVirtualMachine(state, pollConnection); + createVirtualMachine(environment.getSessionName(), environment.isPollConnection()); try { synchronized (myProcessListeners) { - if (state instanceof CommandLineState) { - final TextConsoleBuilder consoleBuilder = ((CommandLineState)state).getConsoleBuilder(); - if (consoleBuilder != null) { - List filters = ExceptionFilters.getFilters(session.getSearchScope()); - for (Filter filter : filters) { - consoleBuilder.addFilter(filter); - } - } - } - myExecutionResult = state.execute(executor, runner); + myExecutionResult = environment.createExecutionResult(); if (myExecutionResult == null) { fail(); return null; @@ -1721,7 +1723,7 @@ public abstract class DebugProcessImpl implements DebugProcess { stop(false); } - private void createVirtualMachine(final RunProfileState state, final boolean pollConnection) { + private void createVirtualMachine(final String sessionName, final boolean pollConnection) { final Semaphore semaphore = new Semaphore(); semaphore.down(); @@ -1763,14 +1765,11 @@ public abstract class DebugProcessImpl implements DebugProcess { // propagate exception only in case we succeded to obtain execution result, // otherwise if the error is induced by the fact that there is nothing to debug, and there is no need to show // this problem to the user - final RunProfile runProfile = state.getRunnerSettings().getRunProfile(); - if (runProfile != null) { - SwingUtilities.invokeLater(new Runnable() { - public void run() { - ExecutionUtil.handleExecutionError(myProject, ToolWindowId.DEBUG, runProfile, e); - } - }); - } + SwingUtilities.invokeLater(new Runnable() { + public void run() { + ExecutionUtil.handleExecutionError(myProject, ToolWindowId.DEBUG, sessionName, e); + } + }); } break; } diff --git a/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerManagerImpl.java b/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerManagerImpl.java index 258b10dcfa0e..0c70ebc4d89a 100644 --- a/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerManagerImpl.java +++ b/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerManagerImpl.java @@ -71,7 +71,7 @@ public class DebuggerManagerImpl extends DebuggerManagerEx { private final BreakpointManager myBreakpointManager; private final List myNameMappers = ContainerUtil.createEmptyCOWList(); private final List> myCustomPositionManagerFactories = new ArrayList>(); - + private final EventDispatcher myDispatcher = EventDispatcher.create(DebuggerManagerListener.class); private final MyDebuggerStateManager myDebuggerStateManager = new MyDebuggerStateManager(); @@ -182,7 +182,7 @@ public class DebuggerManagerImpl extends DebuggerManagerEx { myBreakpointManager.writeExternal(element); } - + public DebuggerSession attachVirtualMachine(Executor executor, ProgramRunner runner, ModuleRunProfile profile, @@ -190,6 +190,17 @@ public class DebuggerManagerImpl extends DebuggerManagerEx { RemoteConnection remoteConnection, boolean pollConnection ) throws ExecutionException { + return attachVirtualMachine(new DefaultDebugEnvironment(myProject, + executor, + runner, + profile, + state, + null, + remoteConnection, + pollConnection)); + } + + public DebuggerSession attachVirtualMachine(DebugEnvironment environment) throws ExecutionException { ApplicationManager.getApplication().assertIsDispatchThread(); final DebugProcessEvents debugProcess = new DebugProcessEvents(myProject); debugProcess.addDebugProcessListener(new DebugProcessAdapter() { @@ -215,9 +226,9 @@ public class DebuggerManagerImpl extends DebuggerManagerEx { debugProcess.removeDebugProcessListener(this); } }); - final DebuggerSession session = new DebuggerSession(profile.getName(), debugProcess); + final DebuggerSession session = new DebuggerSession(environment.getSessionName(), debugProcess); - final ExecutionResult executionResult = session.attach(executor, runner, profile, state, remoteConnection, pollConnection); + final ExecutionResult executionResult = session.attach(environment); if (executionResult == null) { return null; } @@ -225,11 +236,11 @@ public class DebuggerManagerImpl extends DebuggerManagerEx { getContextManager().setState(DebuggerContextUtil.createDebuggerContext(session, session.getContextManager().getContext().getSuspendContext()), session.getState(), DebuggerSession.EVENT_CONTEXT, null); final ProcessHandler processHandler = executionResult.getProcessHandler(); - + synchronized (mySessions) { mySessions.put(processHandler, session); } - + if (!(processHandler instanceof RemoteDebugProcessHandler)) { // add listener only to non-remote process handler: // on Unix systems destroying process does not cause VMDeathEvent to be generated, diff --git a/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerSession.java b/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerSession.java index 23a6eaea4caa..d2b2c5898a7d 100644 --- a/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerSession.java +++ b/java/debugger/impl/src/com/intellij/debugger/impl/DebuggerSession.java @@ -15,9 +15,7 @@ */ package com.intellij.debugger.impl; -import com.intellij.debugger.DebuggerBundle; -import com.intellij.debugger.DebuggerInvocationUtil; -import com.intellij.debugger.SourcePosition; +import com.intellij.debugger.*; import com.intellij.debugger.actions.DebuggerActions; import com.intellij.debugger.engine.*; import com.intellij.debugger.engine.evaluation.EvaluateException; @@ -359,22 +357,29 @@ public class DebuggerSession implements AbstractDebuggerSession { } @Nullable - protected ExecutionResult attach(@NotNull final Executor executor, @NotNull final ProgramRunner runner, final ModuleRunProfile profile, final RunProfileState state, final RemoteConnection remoteConnection, final boolean pollConnection) throws ExecutionException { + protected ExecutionResult attach(@NotNull final Executor executor, + @NotNull final ProgramRunner runner, + final ModuleRunProfile profile, + final RunProfileState state, + final RemoteConnection remoteConnection, + final boolean pollConnection) throws ExecutionException { + return attach(new DefaultDebugEnvironment(myDebugProcess.getProject(), + executor, + runner, + profile, + state, + null, + remoteConnection, + pollConnection)); + } + + @Nullable + protected ExecutionResult attach(DebugEnvironment environment) throws ExecutionException { + RemoteConnection remoteConnection = environment.getRemoteConnection(); final String addressDisplayName = DebuggerBundle.getAddressDisplayName(remoteConnection); final String transportName = DebuggerBundle.getTransportName(remoteConnection); - final Module[] modules = profile.getModules(); - if (modules.length == 0) { - mySearchScope = GlobalSearchScope.allScope(getProject()); - } - else { - GlobalSearchScope scope = GlobalSearchScope.moduleRuntimeScope(modules[0], true); - for (int idx = 1; idx < modules.length; idx++) { - Module module = modules[idx]; - scope = scope.uniteWith(GlobalSearchScope.moduleRuntimeScope(module, true)); - } - mySearchScope = scope; - } - final ExecutionResult executionResult = myDebugProcess.attachVirtualMachine(executor, runner, this, state, remoteConnection, pollConnection); + mySearchScope = environment.getSearchScope(); + final ExecutionResult executionResult = myDebugProcess.attachVirtualMachine(environment, this); getContextManager().setState(SESSION_EMPTY_CONTEXT, STATE_WAITING_ATTACH, EVENT_START_WAIT_ATTACH, DebuggerBundle.message("status.waiting.attach", addressDisplayName, transportName)); return executionResult; } diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/DebuggerPanelsManager.java b/java/debugger/impl/src/com/intellij/debugger/ui/DebuggerPanelsManager.java index 041fb2876416..1b49e59ecce6 100644 --- a/java/debugger/impl/src/com/intellij/debugger/ui/DebuggerPanelsManager.java +++ b/java/debugger/impl/src/com/intellij/debugger/ui/DebuggerPanelsManager.java @@ -15,8 +15,10 @@ */ package com.intellij.debugger.ui; +import com.intellij.debugger.DebugEnvironment; import com.intellij.debugger.DebuggerInvocationUtil; import com.intellij.debugger.DebuggerManagerEx; +import com.intellij.debugger.DefaultDebugEnvironment; import com.intellij.debugger.engine.DebugProcessImpl; import com.intellij.debugger.impl.DebuggerContextImpl; import com.intellij.debugger.impl.DebuggerContextListener; @@ -27,9 +29,7 @@ import com.intellij.debugger.ui.tree.render.BatchEvaluator; import com.intellij.execution.ExecutionException; import com.intellij.execution.ExecutionManager; import com.intellij.execution.Executor; -import com.intellij.execution.configurations.ModuleRunProfile; import com.intellij.execution.configurations.RemoteConnection; -import com.intellij.execution.configurations.RemoteState; import com.intellij.execution.configurations.RunProfileState; import com.intellij.execution.executors.DefaultDebugExecutor; import com.intellij.execution.process.ProcessHandler; @@ -103,10 +103,19 @@ public class DebuggerPanelsManager implements ProjectComponent { RunContentDescriptor reuseContent, RemoteConnection remoteConnection, boolean pollConnection) throws ExecutionException { + return attachVirtualMachine(new DefaultDebugEnvironment(myProject, + executor, + runner, + environment, + state, + reuseContent, + remoteConnection, + pollConnection)); + } - final DebuggerSession debuggerSession = DebuggerManagerEx.getInstanceEx(myProject).attachVirtualMachine( - executor, runner, (ModuleRunProfile) environment.getRunProfile(), state, remoteConnection, pollConnection - ); + @Nullable + public RunContentDescriptor attachVirtualMachine(DebugEnvironment environment) throws ExecutionException { + final DebuggerSession debuggerSession = DebuggerManagerEx.getInstanceEx(myProject).attachVirtualMachine(environment); if (debuggerSession == null) { return null; } @@ -116,16 +125,16 @@ public class DebuggerPanelsManager implements ProjectComponent { debuggerSession.dispose(); return null; } - if (state instanceof RemoteState) { + if (environment.isRemote()) { // optimization: that way BatchEvaluator will not try to lookup the class file in remote VM // which is an expensive operation when executed first time debugProcess.putUserData(BatchEvaluator.REMOTE_SESSION_KEY, Boolean.TRUE); } - final DebuggerSessionTab sessionTab = new DebuggerSessionTab(myProject, debuggerSession.getSessionName(), environment.getRunProfile().getIcon()); + final DebuggerSessionTab sessionTab = new DebuggerSessionTab(myProject, environment.getSessionName(), environment.getIcon()); Disposer.register(myProject, sessionTab); - RunContentDescriptor runContentDescriptor = - sessionTab.attachToSession(debuggerSession, runner, environment); + RunContentDescriptor runContentDescriptor = sessionTab.attachToSession(debuggerSession, environment); + RunContentDescriptor reuseContent = environment.getReuseContent(); if (reuseContent != null) { final ProcessHandler prevHandler = reuseContent.getProcessHandler(); if (prevHandler != null) { diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/DebuggerSessionTab.java b/java/debugger/impl/src/com/intellij/debugger/ui/DebuggerSessionTab.java index 251434eedaf8..3c7b71981e16 100644 --- a/java/debugger/impl/src/com/intellij/debugger/ui/DebuggerSessionTab.java +++ b/java/debugger/impl/src/com/intellij/debugger/ui/DebuggerSessionTab.java @@ -15,6 +15,7 @@ */ package com.intellij.debugger.ui; +import com.intellij.debugger.DebugEnvironment; import com.intellij.debugger.DebuggerBundle; import com.intellij.debugger.actions.DebuggerActions; import com.intellij.debugger.engine.DebugProcessImpl; @@ -30,23 +31,20 @@ import com.intellij.debugger.ui.impl.ThreadsPanel; import com.intellij.debugger.ui.impl.VariablesPanel; import com.intellij.debugger.ui.impl.WatchDebuggerTree; import com.intellij.debugger.ui.impl.watch.*; -import com.intellij.execution.*; -import com.intellij.execution.configurations.RunProfile; +import com.intellij.execution.DefaultExecutionResult; +import com.intellij.execution.ExecutionException; +import com.intellij.execution.ExecutionManager; +import com.intellij.execution.ExecutionResult; import com.intellij.execution.executors.DefaultDebugExecutor; import com.intellij.execution.filters.ExceptionFilters; import com.intellij.execution.filters.Filter; import com.intellij.execution.filters.TextConsoleBuilder; import com.intellij.execution.filters.TextConsoleBuilderFactory; -import com.intellij.execution.runners.ExecutionEnvironment; -import com.intellij.execution.runners.ProgramRunner; -import com.intellij.execution.runners.RestartAction; import com.intellij.execution.ui.ConsoleView; import com.intellij.execution.ui.ExecutionConsoleEx; import com.intellij.execution.ui.RunContentDescriptor; -import com.intellij.execution.ui.actions.CloseAction; import com.intellij.execution.ui.layout.PlaceInGrid; import com.intellij.icons.AllIcons; -import com.intellij.ide.actions.ContextHelpAction; import com.intellij.idea.ActionsBundle; import com.intellij.openapi.Disposable; import com.intellij.openapi.actionSystem.*; @@ -80,14 +78,12 @@ public class DebuggerSessionTab extends DebuggerSessionTabBase implements Dispos private final VariablesPanel myVariablesPanel; private final MainWatchPanel myWatchPanel; - private ProgramRunner myRunner; private volatile DebuggerSession myDebuggerSession; private final MyDebuggerStateManager myStateManager = new MyDebuggerStateManager(); private final FramesPanel myFramesPanel; - private ExecutionEnvironment myEnvironment; - private RunProfile myConfiguration; + private DebugEnvironment myEnvironment; private final ThreadsPanel myThreadsPanel; private static final String THREAD_DUMP_CONTENT_PREFIX = "Dump"; @@ -184,7 +180,7 @@ public class DebuggerSessionTab extends DebuggerSessionTabBase implements Dispos myUi.addContent(threadsContent, 0, PlaceInGrid.left, true); for (Content each : myUi.getContents()) { - updateStatus(each); + updateStatus(each); } myUi.addListener(new ContentManagerAdapter() { @@ -230,13 +226,15 @@ public class DebuggerSessionTab extends DebuggerSessionTabBase implements Dispos myUi.removeContent(myUi.findContent(DebuggerContentInfo.CONSOLE_CONTENT), true); - Content console; + Content console = null; if (myConsole instanceof ExecutionConsoleEx) { ((ExecutionConsoleEx)myConsole).buildUi(myUi); console = myUi.findContent(DebuggerContentInfo.CONSOLE_CONTENT); - LOG.assertTrue(console != null, "Console content was not created"); + if (console == null) { + LOG.debug("Reuse console created with non-debug runner"); + } } - else { + if (console == null) { console = myUi.createContent(DebuggerContentInfo.CONSOLE_CONTENT, myConsole.getComponent(), XDebuggerBundle.message("debugger.session.tab.console.content.name"), XDebuggerUIConstants.CONSOLE_TAB_ICON, myConsole.getPreferredFocusableComponent()); @@ -259,15 +257,7 @@ public class DebuggerSessionTab extends DebuggerSessionTabBase implements Dispos } console.setActions(consoleActions, ActionPlaces.DEBUGGER_TOOLBAR, myConsole.getPreferredFocusableComponent()); - initLogConsoles(myConfiguration, myRunContentDescriptor.getProcessHandler(), myConsole); - DefaultActionGroup group = new DefaultActionGroup(); - final Executor executor = DefaultDebugExecutor.getDebugExecutorInstance(); - RestartAction restarAction = new RestartAction(executor, - myRunner, myRunContentDescriptor.getProcessHandler(), XDebuggerUIConstants.DEBUG_AGAIN_ICON, - myRunContentDescriptor, myEnvironment); - group.add(restarAction); - restarAction.registerShortcut(myUi.getComponent()); if (executionResult instanceof DefaultExecutionResult) { final AnAction[] actions = ((DefaultExecutionResult)executionResult).getRestartActions(); @@ -331,12 +321,11 @@ public class DebuggerSessionTab extends DebuggerSessionTabBase implements Dispos group.addSeparator(); addActionToGroup(group, PinToolwindowTabAction.ACTION_NAME); - group.add(new CloseAction(executor, myRunContentDescriptor, getProject())); - group.add(new ContextHelpAction(executor.getHelpId())); + + myEnvironment.initContent(myRunContentDescriptor, getLogManager(), group); myUi.getOptions().setLeftToolbar(group, ActionPlaces.DEBUGGER_TOOLBAR); - return myRunContentDescriptor; } @@ -384,7 +373,7 @@ public class DebuggerSessionTab extends DebuggerSessionTabBase implements Dispos } public String getSessionName() { - return myConfiguration.getName(); + return myEnvironment.getSessionName(); } public DebuggerStateManager getContextManager() { @@ -427,15 +416,10 @@ public class DebuggerSessionTab extends DebuggerSessionTabBase implements Dispos } } - public RunContentDescriptor attachToSession(final DebuggerSession session, final ProgramRunner runner, final ExecutionEnvironment env) - throws ExecutionException { + public RunContentDescriptor attachToSession(final DebuggerSession session, DebugEnvironment environment) throws ExecutionException { disposeSession(); myDebuggerSession = session; - myRunner = runner; - myEnvironment = env; - myConfiguration = env.getRunProfile(); - - registerFileMatcher(myConfiguration); + myEnvironment = environment; session.getContextManager().addListener(new DebuggerContextListener() { public void changeEvent(DebuggerContextImpl newContext, int event) { diff --git a/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/DebuggerSessionTabBase.java b/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/DebuggerSessionTabBase.java index 7bc4b122db63..4c7147a0b52b 100644 --- a/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/DebuggerSessionTabBase.java +++ b/platform/xdebugger-impl/src/com/intellij/xdebugger/impl/ui/DebuggerSessionTabBase.java @@ -109,6 +109,10 @@ public abstract class DebuggerSessionTabBase implements DebuggerLogConsoleManage } } + protected LogFilesManager getLogManager() { + return myManager; + } + // TODO[oleg]: talk to nick public void setEnvironment(@NotNull final ExecutionEnvironment env) { myEnvironment = env;