replaced <code></code> with more concise {@code}
[idea/community.git] / platform / xdebugger-api / src / com / intellij / xdebugger / breakpoints / XBreakpointType.java
1 /*
2  * Copyright 2000-2016 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
17 package com.intellij.xdebugger.breakpoints;
18
19 import com.intellij.icons.AllIcons;
20 import com.intellij.openapi.extensions.ExtensionPointName;
21 import com.intellij.openapi.project.Project;
22 import com.intellij.xdebugger.XSourcePosition;
23 import com.intellij.xdebugger.breakpoints.ui.XBreakpointCustomPropertiesPanel;
24 import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule;
25 import com.intellij.xdebugger.evaluation.XDebuggerEditorsProvider;
26 import org.jetbrains.annotations.Nls;
27 import org.jetbrains.annotations.NonNls;
28 import org.jetbrains.annotations.NotNull;
29 import org.jetbrains.annotations.Nullable;
30
31 import javax.swing.*;
32 import java.util.Collections;
33 import java.util.Comparator;
34 import java.util.EnumSet;
35 import java.util.List;
36
37 /**
38  * Implement this class to support new type of breakpoints. An implementation should be registered in a plugin.xml:
39  * <p>
40  * &lt;extensions defaultExtensionNs="com.intellij"&gt;<br>
41  * &nbsp;&nbsp;&lt;xdebugger.breakpointType implementation="qualified-class-name"/&gt;<br>
42  * &lt;/extensions&gt;
43  * <p><p>
44  *
45  * Use this class only for breakpoints like exception breakpoints in Java. If a breakpoint will be put on some line in a file use
46  * {@link XLineBreakpointType} instead 
47  *
48  * @author nik
49  */
50 public abstract class XBreakpointType<B extends XBreakpoint<P>, P extends XBreakpointProperties> {
51   public static final ExtensionPointName<XBreakpointType> EXTENSION_POINT_NAME = ExtensionPointName.create("com.intellij.xdebugger.breakpointType");
52   private final @NonNls @NotNull String myId;
53   private final @Nls @NotNull String myTitle;
54   private final boolean mySuspendThreadSupported;
55
56   /**
57    * @param id an unique id of breakpoint type
58    * @param title title of tab in the breakpoints dialog
59    */
60   protected XBreakpointType(@NonNls @NotNull final String id, @Nls @NotNull final String title) {
61     this(id, title, false);
62   }
63
64   /**
65    * @param id                     an unique id of breakpoint type
66    * @param title                  title of tab in the breakpoints dialog
67    * @param suspendThreadSupported {@code true} if suspending only one thread is supported for this type of breakpoints
68    */
69   protected XBreakpointType(@NonNls @NotNull final String id, @Nls @NotNull final String title, boolean suspendThreadSupported) {
70     myId = id;
71     myTitle = title;
72     mySuspendThreadSupported = suspendThreadSupported;
73   }
74
75   @Nullable
76   public P createProperties() {
77     return null;
78   }
79
80   /**
81    * @return {@code true} if suspending only one thread is supported
82    */
83   public boolean isSuspendThreadSupported() {
84     return mySuspendThreadSupported;
85   }
86
87   public SuspendPolicy getDefaultSuspendPolicy() {
88     return SuspendPolicy.ALL;
89   }
90
91   public enum StandardPanels {SUSPEND_POLICY, ACTIONS, DEPENDENCY}
92
93   public EnumSet<StandardPanels> getVisibleStandardPanels() {
94     return EnumSet.allOf(StandardPanels.class);
95   }
96
97   @NotNull
98   public final String getId() {
99     return myId;
100   }
101
102   @NotNull
103   public String getTitle() {
104     return myTitle;
105   }
106
107   @NotNull 
108   public Icon getEnabledIcon() {
109     return AllIcons.Debugger.Db_set_breakpoint;
110   }
111
112   @NotNull
113   public Icon getDisabledIcon() {
114     return AllIcons.Debugger.Db_disabled_breakpoint;
115   }
116
117   @NotNull
118   public Icon getMutedEnabledIcon() {
119     return AllIcons.Debugger.Db_muted_breakpoint;
120   }
121
122   @NotNull
123   public Icon getMutedDisabledIcon() {
124     return AllIcons.Debugger.Db_muted_disabled_breakpoint;
125   }
126
127   /**
128    * @return the icon which is shown for a dependent breakpoint until its master breakpoint is reached
129    */
130   @NotNull
131   public Icon getInactiveDependentIcon() {
132     return getDisabledDependentIcon();
133   }
134
135   /**
136    * @deprecated override {@link #getInactiveDependentIcon()} instead
137    */
138   @NotNull
139   public Icon getDisabledDependentIcon() {
140     return AllIcons.Debugger.Db_dep_line_breakpoint;
141   }
142
143   public abstract String getDisplayText(B breakpoint);
144
145   @Nullable 
146   public XBreakpointCustomPropertiesPanel<B> createCustomConditionsPanel() {
147     return null;
148   }
149
150   @Nullable
151   public XBreakpointCustomPropertiesPanel<B> createCustomPropertiesPanel(@NotNull Project project) {
152     return createCustomPropertiesPanel();
153   }
154
155   /**
156    * @deprecated override {@link #createCustomPropertiesPanel(Project)} instead
157    */
158   @Nullable
159   public XBreakpointCustomPropertiesPanel<B> createCustomPropertiesPanel() {
160     return null;
161   }
162
163   @Nullable
164   public XBreakpointCustomPropertiesPanel<B> createCustomRightPropertiesPanel(@NotNull Project project) {
165     return null;
166   }
167
168   @Nullable
169   public XBreakpointCustomPropertiesPanel<B> createCustomTopPropertiesPanel(@NotNull Project project) {
170     return null;
171   }
172
173   /**
174    * @deprecated override {@link #getEditorsProvider(B, Project)} instead
175    */
176   @Nullable
177   public XDebuggerEditorsProvider getEditorsProvider() {
178     return null;
179   }
180
181   @Nullable
182   public XDebuggerEditorsProvider getEditorsProvider(@NotNull B breakpoint, @NotNull Project project) {
183     return getEditorsProvider();
184   }
185
186   public List<XBreakpointGroupingRule<B, ?>> getGroupingRules() {
187     return Collections.emptyList();
188   }
189
190   @NotNull 
191   public Comparator<B> getBreakpointComparator() {
192     return (b, b1) -> (int)(b1.getTimeStamp() - b.getTimeStamp());
193     //return XDebuggerUtil.getInstance().getDefaultBreakpointComparator(this);
194   }
195
196   /**
197    * Return {@code true} from this method in order to allow adding breakpoints from the "Breakpoints" dialog. Also override
198    * {@link XBreakpointType#addBreakpoint(Project,JComponent)} method.
199    * @return {@code true} if "Add" button should be visible in "Breakpoints" dialog
200    */
201   public boolean isAddBreakpointButtonVisible() {
202     return false;
203   }
204
205   /**
206    * This method is called then "Add" button is pressed in the "Breakpoints" dialog 
207    * @param project
208    * @param parentComponent
209    * @return the created breakpoint or {@code null} if breakpoint wasn't created
210    */
211   @Nullable
212   public B addBreakpoint(final Project project, JComponent parentComponent) {
213     return null;
214   }
215
216   /**
217    * Returns properties of the default breakpoint. The default breakpoints cannot be deleted and is always shown on top of the breakpoints
218    * list in the dialog.
219    *
220    * @return a default breakpoint or {@code null} if default breakpoint isn't supported
221    */
222   @Nullable
223   public XBreakpoint<P> createDefaultBreakpoint(@NotNull XBreakpointCreator<P> creator) {
224     return null;
225   }
226
227   public boolean shouldShowInBreakpointsDialog(@NotNull Project project) {
228     return true;
229   }
230
231   @Nullable @NonNls
232   public String getBreakpointsDialogHelpTopic() {
233     return null;
234   }
235
236   /**
237    * Override this method to define source position for a breakpoint. It will be used e.g. by 'Go To' and 'View Source' buttons in 'Breakpoints' dialog
238    */
239   @Nullable
240   public XSourcePosition getSourcePosition(@NotNull XBreakpoint<P> breakpoint) {
241     return null;
242   }
243
244   public String getShortText(B breakpoint) {
245     return getDisplayText(breakpoint);
246   }
247
248   public interface XBreakpointCreator<P extends XBreakpointProperties> {
249     @NotNull
250     XBreakpoint<P> createBreakpoint(@Nullable P properties);
251   }
252 }