3c346146ef60056a3ecf7377181c566accc26462
[idea/community.git] / java / debugger / impl / src / com / intellij / debugger / ui / DebuggerPanelsManager.java
1 /*
2  * Copyright 2000-2015 JetBrains s.r.o.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package com.intellij.debugger.ui;
17
18 import com.intellij.debugger.DebugEnvironment;
19 import com.intellij.debugger.DebugUIEnvironment;
20 import com.intellij.debugger.DebuggerManagerEx;
21 import com.intellij.debugger.DefaultDebugUIEnvironment;
22 import com.intellij.debugger.engine.DebugProcessImpl;
23 import com.intellij.debugger.engine.JavaDebugProcess;
24 import com.intellij.debugger.impl.DebuggerContextImpl;
25 import com.intellij.debugger.impl.DebuggerSession;
26 import com.intellij.debugger.impl.DebuggerStateManager;
27 import com.intellij.debugger.ui.impl.MainWatchPanel;
28 import com.intellij.debugger.ui.tree.render.BatchEvaluator;
29 import com.intellij.execution.ExecutionException;
30 import com.intellij.execution.ExecutionManager;
31 import com.intellij.execution.Executor;
32 import com.intellij.execution.configurations.RemoteConnection;
33 import com.intellij.execution.configurations.RunProfileState;
34 import com.intellij.execution.executors.DefaultDebugExecutor;
35 import com.intellij.execution.runners.ExecutionEnvironment;
36 import com.intellij.execution.runners.ExecutionEnvironmentBuilder;
37 import com.intellij.execution.runners.ProgramRunner;
38 import com.intellij.execution.ui.RunContentDescriptor;
39 import com.intellij.execution.ui.RunContentManager;
40 import com.intellij.execution.ui.RunContentWithExecutorListener;
41 import com.intellij.openapi.components.ProjectComponent;
42 import com.intellij.openapi.diagnostic.Logger;
43 import com.intellij.openapi.editor.colors.EditorColorsManager;
44 import com.intellij.openapi.project.Project;
45 import com.intellij.openapi.util.Comparing;
46 import com.intellij.xdebugger.XDebugProcess;
47 import com.intellij.xdebugger.XDebugProcessStarter;
48 import com.intellij.xdebugger.XDebugSession;
49 import com.intellij.xdebugger.XDebuggerManager;
50 import org.jetbrains.annotations.NotNull;
51 import org.jetbrains.annotations.Nullable;
52
53 public class DebuggerPanelsManager implements ProjectComponent {
54   private static final Logger LOG = Logger.getInstance("#com.intellij.debugger.ui.DebuggerPanelsManager");
55
56   private final Project myProject;
57   private final ExecutionManager myExecutionManager;
58
59   //private final PositionHighlighter myEditorManager;
60   //private final HashMap<ProcessHandler, DebuggerSessionTab> mySessionTabs = new HashMap<ProcessHandler, DebuggerSessionTab>();
61
62   public DebuggerPanelsManager(Project project, final EditorColorsManager colorsManager, ExecutionManager executionManager) {
63     myProject = project;
64     myExecutionManager = executionManager;
65
66     //myEditorManager = new PositionHighlighter(myProject, getContextManager());
67     //
68     //final EditorColorsListener myColorsListener = new EditorColorsListener() {
69     //  public void globalSchemeChange(EditorColorsScheme scheme) {
70     //    myEditorManager.updateContextPointDescription();
71     //  }
72     //};
73     //colorsManager.addEditorColorsListener(myColorsListener);
74     //Disposer.register(project, new Disposable() {
75     //  public void dispose() {
76     //    colorsManager.removeEditorColorsListener(myColorsListener);
77     //  }
78     //});
79     //
80     //getContextManager().addListener(new DebuggerContextListener() {
81     //  public void changeEvent(final DebuggerContextImpl newContext, int event) {
82     //    if (event == DebuggerSession.EVENT_PAUSE) {
83     //      DebuggerInvocationUtil.invokeLater(myProject, new Runnable() {
84     //        public void run() {
85     //          toFront(newContext.getDebuggerSession());
86     //        }
87     //      });
88     //    }
89     //  }
90     //});
91   }
92
93   private DebuggerStateManager getContextManager() {
94     return DebuggerManagerEx.getInstanceEx(myProject).getContextManager();
95   }
96
97   @Nullable
98   @Deprecated
99   /**
100    * @deprecated to remove in IDEA 15
101    */
102   public RunContentDescriptor attachVirtualMachine(Executor executor,
103                                                    @NotNull ProgramRunner runner,
104                                                    @NotNull ExecutionEnvironment environment,
105                                                    RunProfileState state,
106                                                    RunContentDescriptor reuseContent,
107                                                    RemoteConnection remoteConnection,
108                                                    boolean pollConnection) throws ExecutionException {
109     return attachVirtualMachine(new ExecutionEnvironmentBuilder(environment)
110                                   .executor(executor)
111                                   .runner(runner)
112                                   .contentToReuse(reuseContent)
113                                   .build(), state, remoteConnection, pollConnection);
114   }
115
116   @Nullable
117   public RunContentDescriptor attachVirtualMachine(@NotNull ExecutionEnvironment environment,
118                                                    RunProfileState state,
119                                                    RemoteConnection remoteConnection,
120                                                    boolean pollConnection) throws ExecutionException {
121     return attachVirtualMachine(new DefaultDebugUIEnvironment(environment, state, remoteConnection, pollConnection));
122   }
123
124   @Nullable
125   public RunContentDescriptor attachVirtualMachine(DebugUIEnvironment environment) throws ExecutionException {
126     final DebugEnvironment modelEnvironment = environment.getEnvironment();
127     final DebuggerSession debuggerSession = DebuggerManagerEx.getInstanceEx(myProject).attachVirtualMachine(modelEnvironment);
128     if (debuggerSession == null) {
129       return null;
130     }
131
132     final DebugProcessImpl debugProcess = debuggerSession.getProcess();
133     if (debugProcess.isDetached() || debugProcess.isDetaching()) {
134       debuggerSession.dispose();
135       return null;
136     }
137     if (modelEnvironment.isRemote()) {
138       // optimization: that way BatchEvaluator will not try to lookup the class file in remote VM
139       // which is an expensive operation when executed first time
140       debugProcess.putUserData(BatchEvaluator.REMOTE_SESSION_KEY, Boolean.TRUE);
141     }
142
143     XDebugSession debugSession =
144       XDebuggerManager.getInstance(myProject).startSessionAndShowTab(modelEnvironment.getSessionName(), environment.getReuseContent(), new XDebugProcessStarter() {
145         @Override
146         @NotNull
147         public XDebugProcess start(@NotNull XDebugSession session) {
148           return JavaDebugProcess.create(session, debuggerSession);
149         }
150       });
151     return debugSession.getRunContentDescriptor();
152   }
153
154
155   @Override
156   public void projectOpened() {
157     myProject.getMessageBus().connect(myProject).subscribe(RunContentManager.TOPIC, new RunContentWithExecutorListener() {
158       @Override
159       public void contentSelected(@Nullable RunContentDescriptor descriptor, @NotNull Executor executor) {
160         if (executor == DefaultDebugExecutor.getDebugExecutorInstance()) {
161           DebuggerSession session = descriptor == null ? null : getSession(myProject, descriptor);
162           if (session != null) {
163             getContextManager().setState(session.getContextManager().getContext(), session.getState(), DebuggerSession.EVENT_CONTEXT, null);
164           }
165           else {
166             getContextManager().setState(DebuggerContextImpl.EMPTY_CONTEXT, DebuggerSession.STATE_DISPOSED, DebuggerSession.EVENT_CONTEXT, null);
167           }
168         }
169       }
170
171       @Override
172       public void contentRemoved(@Nullable RunContentDescriptor descriptor, @NotNull Executor executor) {
173       }
174     });
175   }
176
177   @Override
178   public void projectClosed() {
179   }
180
181   @Override
182   @NotNull
183   public String getComponentName() {
184     return "DebuggerPanelsManager";
185   }
186
187   @Override
188   public void initComponent() {
189   }
190
191   @Override
192   public void disposeComponent() {
193   }
194
195   public static DebuggerPanelsManager getInstance(Project project) {
196     return project.getComponent(DebuggerPanelsManager.class);
197   }
198
199   @Nullable
200   public MainWatchPanel getWatchPanel() {
201     DebuggerSessionTab sessionTab = getSessionTab();
202     return sessionTab != null ? sessionTab.getWatchPanel() : null;
203   }
204
205   @Nullable
206   public DebuggerSessionTab getSessionTab() {
207     DebuggerContextImpl context = DebuggerManagerEx.getInstanceEx(myProject).getContext();
208     return getSessionTab(context.getDebuggerSession());
209   }
210
211   public void showFramePanel() {
212     DebuggerSessionTab sessionTab = getSessionTab();
213     if (sessionTab != null) {
214       sessionTab.showFramePanel();
215     }
216   }
217
218   public void toFront(DebuggerSession session) {
219     DebuggerSessionTab sessionTab = getSessionTab(session);
220     if (sessionTab != null) {
221       sessionTab.toFront(true, null);
222     }
223   }
224
225   private static DebuggerSession getSession(Project project, RunContentDescriptor descriptor) {
226     for (JavaDebugProcess process : XDebuggerManager.getInstance(project).getDebugProcesses(JavaDebugProcess.class)) {
227       if (Comparing.equal(process.getProcessHandler(), descriptor.getProcessHandler())) {
228         return process.getDebuggerSession();
229       }
230     }
231     return null;
232   }
233
234   @Nullable
235   private DebuggerSessionTab getSessionTab(DebuggerSession session) {
236     //return session != null ? getSessionTab(session.getProcess().getExecutionResult().getProcessHandler()) : null;
237     return null;
238   }
239
240 }