breakpoints ui. add breakpoint action

java/debugger/impl/src/com/intellij/debugger/ui/JavaDebuggerSupport.java

@@ -21,7 +21,10 @@ import com.intellij.debugger.impl.DebuggerContextImpl;
 import com.intellij.debugger.settings.*;
 import com.intellij.debugger.ui.breakpoints.*;
 import com.intellij.ide.DataManager;
+import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.intellij.openapi.actionSystem.PlatformDataKeys;
+import com.intellij.openapi.actionSystem.Presentation;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.markup.GutterIconRenderer;
 import com.intellij.openapi.editor.markup.RangeHighlighter;
@@ -196,6 +199,16 @@ public class JavaDebuggerSupport extends DebuggerSupport {
       return panels;
     }
 
+    @Override
+    public AnAction[] getAddBreakpointActions(@NotNull Project project) {
+      List<AnAction> result = new ArrayList<AnAction>();
+      BreakpointFactory[] breakpointFactories = BreakpointFactory.getBreakpointFactories();
+      for (BreakpointFactory breakpointFactory : breakpointFactories) {
+        result.add(new AddJavaBreakpointAction(breakpointFactory));
+      }
+      return result.toArray(new AnAction[result.size()]);
+    }
+
     public int getPriority() {
       return 1;
     }
@@ -230,6 +243,27 @@ public class JavaDebuggerSupport extends DebuggerSupport {
         }
       }
     }
+
+    private static class AddJavaBreakpointAction extends AnAction {
+      private BreakpointFactory myBreakpointFactory;
+
+      public AddJavaBreakpointAction(BreakpointFactory breakpointFactory) {
+        myBreakpointFactory = breakpointFactory;
+        Presentation p = getTemplatePresentation();
+        p.setIcon(myBreakpointFactory.getIcon());
+        p.setText(breakpointFactory.getDisplayName());
+      }
+
+      @Override
+      public void update(AnActionEvent e) {
+        e.getPresentation().setVisible(myBreakpointFactory.canAddBreakpoints());
+      }
+
+      @Override
+      public void actionPerformed(AnActionEvent e) {
+        myBreakpointFactory.addBreakpoint(getEventProject(e));
+      }
+    }
   }
 
   public static class JavaDebuggerSettingsPanelProvider extends DebuggerSettingsPanelProvider {

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointFactory.java

@@ -15,18 +15,13 @@
  */
 package com.intellij.debugger.ui.breakpoints;
 
-import com.intellij.debugger.SourcePosition;
 import com.intellij.debugger.ui.breakpoints.actions.BreakpointPanelAction;
+import com.intellij.openapi.actionSystem.AnAction;
 import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.editor.LogicalPosition;
 import com.intellij.openapi.extensions.ExtensionPointName;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.util.Key;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.ui.ColoredListCellRenderer;
-import com.intellij.ui.popup.util.DetailView;
-import com.intellij.ui.popup.util.DetailViewImpl;
 import com.intellij.xdebugger.breakpoints.ui.BreakpointItem;
 import org.jdom.Element;
 import org.jetbrains.annotations.Nullable;
@@ -74,8 +69,6 @@ public abstract class BreakpointFactory {
   protected void configureBreakpointPanel(BreakpointPanel panel) {
   }
 
-  ;
-
   protected abstract String getHelpID();
 
   public abstract String getDisplayName();
@@ -85,49 +78,16 @@ public abstract class BreakpointFactory {
 
   protected abstract BreakpointPanelAction[] createBreakpointPanelActions(Project project, DialogWrapper parentDialog);
 
+  @Nullable
+  public Breakpoint addBreakpoint(Project project) {
+    return null;
+  }
+
+  public boolean canAddBreakpoints() {
+    return false;
+  }
+
   public BreakpointItem createBreakpointItem(final Breakpoint breakpoint) {
-    return new BreakpointItem() {
-      @Override
-      public void setupRenderer(ColoredListCellRenderer renderer, Project project, boolean selected) {
-        renderer.setIcon(breakpoint.getIcon());
-        renderer.append(breakpoint.getDisplayName());
-      }
-
-      @Override
-      public void updateMnemonicLabel(JLabel label) {
-        //To change body of implemented methods use File | Settings | File Templates.
-      }
-
-      @Override
-      public void execute(Project project) {
-        //To change body of implemented methods use File | Settings | File Templates.
-      }
-
-      @Override
-      public String speedSearchText() {
-        return breakpoint.getDisplayName();
-      }
-
-      @Override
-      public String footerText() {
-        return breakpoint.getDisplayName();
-      }
-
-      @Override
-      public void updateDetailView(DetailView panel) {
-        if (breakpoint instanceof LineBreakpoint) {
-          SourcePosition sourcePosition = ((LineBreakpoint)breakpoint).getSourcePosition();
-          VirtualFile virtualFile = sourcePosition.getFile().getVirtualFile();
-          panel.navigateInPreviewEditor(virtualFile, new LogicalPosition(sourcePosition.getLine(), 0));
-        }
-
-        BreakpointPropertiesPanel breakpointPropertiesPanel = createBreakpointPropertiesPanel(breakpoint.getProject(), false);
-        if (breakpointPropertiesPanel != null) {
-          breakpointPropertiesPanel.initFrom(breakpoint, true);
-          final JPanel mainPanel = breakpointPropertiesPanel.getPanel();
-          panel.setDetailPanel(mainPanel);
-        }
-      }
-    };
+    return new JavaBreakpointItem(this, breakpoint);
   }
 }

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/ExceptionBreakpointFactory.java

@@ -39,7 +39,7 @@ import java.awt.event.ActionEvent;
  * @author Eugene Zhuravlev
  *         Date: Apr 26, 2005
  */
-public class ExceptionBreakpointFactory extends BreakpointFactory{
+public class ExceptionBreakpointFactory extends BreakpointFactory {
   public Breakpoint createBreakpoint(Project project, final Element element) {
     return new ExceptionBreakpoint(project);
   }
@@ -77,47 +77,43 @@ public class ExceptionBreakpointFactory extends BreakpointFactory{
   protected BreakpointPanelAction[] createBreakpointPanelActions(final Project project, DialogWrapper parentDialog) {
     return new BreakpointPanelAction[]{
       new SwitchViewAction(),
-      new AddExceptionBreakpointAction(project),
+      new AddAction(this, project),
       new RemoveAction(project) {
-        public void update() {
-          super.update();
-          if (getButton().isEnabled()) {
-            Breakpoint[] selectedBreakpoints = getPanel().getSelectedBreakpoints();
-            for (Breakpoint bp : selectedBreakpoints) {
-              if (bp instanceof AnyExceptionBreakpoint) {
-                getButton().setEnabled(false);
-              }
+      public void update() {
+        super.update();
+        if (getButton().isEnabled()) {
+          Breakpoint[] selectedBreakpoints = getPanel().getSelectedBreakpoints();
+          for (Breakpoint bp : selectedBreakpoints) {
+            if (bp instanceof AnyExceptionBreakpoint) {
+              getButton().setEnabled(false);
             }
           }
         }
-      },
-      new ToggleGroupByClassesAction(),
-      new ToggleFlattenPackagesAction(),
-    };
+      }
+    }, new ToggleGroupByClassesAction(), new ToggleFlattenPackagesAction(),};
   }
 
-
   public BreakpointPanel createBreakpointPanel(final Project project, final DialogWrapper parentDialog) {
-    BreakpointPanel panel = new BreakpointPanel(project,
-                                                createBreakpointPropertiesPanel(project, false),
-                                                createBreakpointPanelActions(project, parentDialog),
-                                                getBreakpointCategory(), getDisplayName(), getHelpID()){
-      public void resetBreakpoints() {
-        super.resetBreakpoints();
-        Breakpoint[] breakpoints = getBreakpointManager().getBreakpoints(getBreakpointCategory());
-        final AnyExceptionBreakpoint anyExceptionBreakpoint = DebuggerManagerEx.getInstanceEx(project).getBreakpointManager().getAnyExceptionBreakpoint();
-        boolean found = false;
-        for (Breakpoint breakpoint : breakpoints) {
-          if (breakpoint.equals(anyExceptionBreakpoint)) {
-            found = true;
-            break;
+    BreakpointPanel panel =
+      new BreakpointPanel(project, createBreakpointPropertiesPanel(project, false), createBreakpointPanelActions(project, parentDialog),
+                          getBreakpointCategory(), getDisplayName(), getHelpID()) {
+        public void resetBreakpoints() {
+          super.resetBreakpoints();
+          Breakpoint[] breakpoints = getBreakpointManager().getBreakpoints(getBreakpointCategory());
+          final AnyExceptionBreakpoint anyExceptionBreakpoint =
+            DebuggerManagerEx.getInstanceEx(project).getBreakpointManager().getAnyExceptionBreakpoint();
+          boolean found = false;
+          for (Breakpoint breakpoint : breakpoints) {
+            if (breakpoint.equals(anyExceptionBreakpoint)) {
+              found = true;
+              break;
+            }
+          }
+          if (!found) {
+            insertBreakpointAt(anyExceptionBreakpoint, 0);
           }
         }
-        if (!found) {
-          insertBreakpointAt(anyExceptionBreakpoint, 0);
-        }
-      }
-    };
+      };
     configureBreakpointPanel(panel);
     return panel;
   }
@@ -126,29 +122,27 @@ public class ExceptionBreakpointFactory extends BreakpointFactory{
     return ExceptionBreakpoint.CATEGORY;
   }
 
-  private static class AddExceptionBreakpointAction extends AddAction {
-    private final Project myProject;
-
-    public AddExceptionBreakpointAction(Project project) {
-      myProject = project;
-    }
-
-    public void actionPerformed(ActionEvent e) {
-      final PsiClass throwableClass =
-        JavaPsiFacade.getInstance(myProject).findClass("java.lang.Throwable", GlobalSearchScope.allScope(myProject));
-      TreeClassChooser chooser =
-        TreeClassChooserFactory.getInstance(myProject).createInheritanceClassChooser(
-          DebuggerBundle.message("add.exception.breakpoint.classchooser.title"), GlobalSearchScope.allScope(myProject),
-          throwableClass, true, true, null);
-      chooser.showDialog();
-      PsiClass selectedClass = chooser.getSelected();
-      String qName = selectedClass == null ? null : JVMNameUtil.getNonAnonymousClassName(selectedClass);
-
-      if (qName != null && qName.length() > 0) {
-        ExceptionBreakpoint breakpoint = DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().addExceptionBreakpoint(qName, ((PsiClassOwner)selectedClass.getContainingFile()).getPackageName());
-        getPanel().addBreakpoint(breakpoint);
-      }
-    }
+  @Override
+  public boolean canAddBreakpoints() {
+    return true;
   }
 
+  @Override
+  public Breakpoint addBreakpoint(Project project) {
+    ExceptionBreakpoint breakpoint = null;
+    final PsiClass throwableClass =
+      JavaPsiFacade.getInstance(project).findClass("java.lang.Throwable", GlobalSearchScope.allScope(project));
+    TreeClassChooser chooser = TreeClassChooserFactory.getInstance(project)
+      .createInheritanceClassChooser(DebuggerBundle.message("add.exception.breakpoint.classchooser.title"),
+                                     GlobalSearchScope.allScope(project), throwableClass, true, true, null);
+    chooser.showDialog();
+    PsiClass selectedClass = chooser.getSelected();
+    String qName = selectedClass == null ? null : JVMNameUtil.getNonAnonymousClassName(selectedClass);
+
+    if (qName != null && qName.length() > 0) {
+      breakpoint = DebuggerManagerEx.getInstanceEx(project).getBreakpointManager()
+        .addExceptionBreakpoint(qName, ((PsiClassOwner)selectedClass.getContainingFile()).getPackageName());
+    }
+    return breakpoint;
+  }
 }

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/FieldBreakpointFactory.java

@@ -25,6 +25,7 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.ui.Messages;
 import com.intellij.openapi.util.Key;
+import com.intellij.openapi.util.Ref;
 import com.intellij.psi.*;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jdom.Element;
@@ -73,7 +74,7 @@ public class FieldBreakpointFactory extends BreakpointFactory{
   protected BreakpointPanelAction[] createBreakpointPanelActions(final Project project, final DialogWrapper parentDialog) {
     return new BreakpointPanelAction[] {
       new SwitchViewAction(),
-      new AddFieldBreakpointAction(project),
+      new AddAction(this, project),
       new GotoSourceAction(project) {
         public void actionPerformed(ActionEvent e) {
           super.actionPerformed(e);
@@ -91,65 +92,61 @@ public class FieldBreakpointFactory extends BreakpointFactory{
     return FieldBreakpoint.CATEGORY;
   }
 
-  private static class AddFieldBreakpointAction extends AddAction {
-    private final Project myProject;
-
-    public AddFieldBreakpointAction(Project project) {
-      myProject = project;
-    }
-
-    public void actionPerformed(ActionEvent e) {
-      AddFieldBreakpointDialog dialog = new AddFieldBreakpointDialog(myProject) {
-        protected boolean validateData() {
-          String className = getClassName();
-          if (className.length() == 0) {
-            Messages.showMessageDialog(myProject, DebuggerBundle.message("error.field.breakpoint.class.name.not.specified"),
-                                       DebuggerBundle.message("add.field.breakpoint.dialog.title"), Messages.getErrorIcon());
-            return false;
-          }
-          String fieldName = getFieldName();
-          if (fieldName.length() == 0) {
-            Messages.showMessageDialog(myProject, DebuggerBundle.message("error.field.breakpoint.field.name.not.specified"),
-                                       DebuggerBundle.message("add.field.breakpoint.dialog.title"), Messages.getErrorIcon());
-            return false;
-          }
-          PsiClass psiClass = JavaPsiFacade.getInstance(myProject).findClass(className, GlobalSearchScope.allScope(myProject));
-          if (psiClass != null) {
-            PsiFile  psiFile  = psiClass.getContainingFile();
-            Document document = PsiDocumentManager.getInstance(myProject).getDocument(psiFile);
-            if(document != null) {
-              PsiField field = psiClass.findFieldByName(fieldName, true);
-              if(field != null) {
-                int line = document.getLineNumber(field.getTextOffset());
-                FieldBreakpoint fieldBreakpoint = DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().addFieldBreakpoint(document, line, fieldName);
-                if (fieldBreakpoint != null) {
-                  getPanel().addBreakpoint(fieldBreakpoint);
-                  return true;
-                }
-              }
-              else {
-                Messages.showMessageDialog(
-                  myProject,
-                  DebuggerBundle.message("error.field.breakpoint.field.not.found", className, fieldName, fieldName),
-                  CommonBundle.getErrorTitle(),
-                  Messages.getErrorIcon()
-                );
-
-              }
-            }
-          } else {
-            Messages.showMessageDialog(
-              myProject,
-              DebuggerBundle.message("error.field.breakpoint.class.sources.not.found", className, fieldName, className),
-              CommonBundle.getErrorTitle(),
-              Messages.getErrorIcon()
-            );
-          }
+  @Override
+  public Breakpoint addBreakpoint(final Project project) {
+    final Ref<Breakpoint> result = Ref.create(null);
+    AddFieldBreakpointDialog dialog = new AddFieldBreakpointDialog(project) {
+      protected boolean validateData() {
+        String className = getClassName();
+        if (className.length() == 0) {
+          Messages.showMessageDialog(project, DebuggerBundle.message("error.field.breakpoint.class.name.not.specified"),
+                                     DebuggerBundle.message("add.field.breakpoint.dialog.title"), Messages.getErrorIcon());
           return false;
         }
-      };
-      dialog.show();
-    }
+        String fieldName = getFieldName();
+        if (fieldName.length() == 0) {
+          Messages.showMessageDialog(project, DebuggerBundle.message("error.field.breakpoint.field.name.not.specified"),
+                                     DebuggerBundle.message("add.field.breakpoint.dialog.title"), Messages.getErrorIcon());
+          return false;
+        }
+        PsiClass psiClass = JavaPsiFacade.getInstance(project).findClass(className, GlobalSearchScope.allScope(project));
+        if (psiClass != null) {
+          PsiFile psiFile  = psiClass.getContainingFile();
+          Document document = PsiDocumentManager.getInstance(project).getDocument(psiFile);
+          if(document != null) {
+            PsiField field = psiClass.findFieldByName(fieldName, true);
+            if(field != null) {
+              int line = document.getLineNumber(field.getTextOffset());
+              FieldBreakpoint fieldBreakpoint = DebuggerManagerEx.getInstanceEx(project).getBreakpointManager().addFieldBreakpoint(document, line, fieldName);
+              if (fieldBreakpoint != null) {
+                result.set(fieldBreakpoint);
+                return true;
+              }
+            }
+            else {
+              Messages.showMessageDialog(project,
+                DebuggerBundle.message("error.field.breakpoint.field.not.found", className, fieldName, fieldName),
+                CommonBundle.getErrorTitle(),
+                Messages.getErrorIcon()
+              );
+            }
+          }
+        } else {
+          Messages.showMessageDialog(project,
+            DebuggerBundle.message("error.field.breakpoint.class.sources.not.found", className, fieldName, className),
+            CommonBundle.getErrorTitle(),
+            Messages.getErrorIcon()
+          );
+        }
+        return false;
+      }
+    };
+    dialog.show();
+    return result.get();
   }
 
+  @Override
+  public boolean canAddBreakpoints() {
+    return true;
+  }
 }

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaBreakpointItem.java

@@ -0,0 +1,96 @@
+/*
+ * 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.ui.breakpoints;
+
+import com.intellij.debugger.SourcePosition;
+import com.intellij.openapi.editor.LogicalPosition;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.ui.ColoredListCellRenderer;
+import com.intellij.ui.popup.util.DetailView;
+import com.intellij.xdebugger.breakpoints.ui.BreakpointItem;
+
+import javax.swing.*;
+
+/**
+* Created with IntelliJ IDEA.
+* User: intendia
+* Date: 10.05.12
+* Time: 3:16
+* To change this template use File | Settings | File Templates.
+*/
+class JavaBreakpointItem implements BreakpointItem {
+  private final Breakpoint myBreakpoint;
+  private BreakpointFactory myBreakpointFactory;
+
+  public JavaBreakpointItem(BreakpointFactory breakpointFactory, Breakpoint breakpoint) {
+    myBreakpointFactory = breakpointFactory;
+    myBreakpoint = breakpoint;
+  }
+
+  @Override
+  public void setupRenderer(ColoredListCellRenderer renderer, Project project, boolean selected) {
+    renderer.setIcon(myBreakpoint.getIcon());
+    renderer.append(myBreakpoint.getDisplayName());
+  }
+
+  @Override
+  public void updateMnemonicLabel(JLabel label) {
+    //To change body of implemented methods use File | Settings | File Templates.
+  }
+
+  @Override
+  public void execute(Project project) {
+    //To change body of implemented methods use File | Settings | File Templates.
+  }
+
+  @Override
+  public String speedSearchText() {
+    return myBreakpoint.getDisplayName();
+  }
+
+  @Override
+  public String footerText() {
+    return myBreakpoint.getDisplayName();
+  }
+
+  @Override
+  public void updateDetailView(DetailView panel) {
+    if (myBreakpoint instanceof LineBreakpoint) {
+      SourcePosition sourcePosition = ((LineBreakpoint)myBreakpoint).getSourcePosition();
+      VirtualFile virtualFile = sourcePosition.getFile().getVirtualFile();
+      panel.navigateInPreviewEditor(virtualFile, new LogicalPosition(sourcePosition.getLine(), 0));
+    }
+
+    BreakpointPropertiesPanel breakpointPropertiesPanel = myBreakpointFactory
+      .createBreakpointPropertiesPanel(myBreakpoint.getProject(), false);
+    if (breakpointPropertiesPanel != null) {
+      breakpointPropertiesPanel.initFrom(myBreakpoint, true);
+      final JPanel mainPanel = breakpointPropertiesPanel.getPanel();
+      panel.setDetailPanel(mainPanel);
+    }
+  }
+
+  @Override
+  public boolean allowedToRemove() {
+    return false;  //To change body of implemented methods use File | Settings | File Templates.
+  }
+
+  @Override
+  public Object getBreakpoint() {
+    return myBreakpoint;
+  }
+}

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/MethodBreakpointFactory.java

@@ -63,7 +63,7 @@ public class MethodBreakpointFactory extends BreakpointFactory{
   protected BreakpointPanelAction[] createBreakpointPanelActions(Project project, final DialogWrapper parentDialog) {
     return new BreakpointPanelAction[]{
       new SwitchViewAction(),
-      new AddWildcardBreakpointAction(project),
+      new AddAction(this, project),
       new GotoSourceAction(project) {
         public void actionPerformed(ActionEvent e) {
           super.actionPerformed(e);
@@ -87,23 +87,19 @@ public class MethodBreakpointFactory extends BreakpointFactory{
     return MethodBreakpoint.CATEGORY;
   }
 
-  private static class AddWildcardBreakpointAction extends AddAction {
-    private final Project myProject;
+  @Override
+  public boolean canAddBreakpoints() {
+    return true;
+  }
 
-    public AddWildcardBreakpointAction(Project project) {
-      myProject = project;
-    }
-
-    public void actionPerformed(ActionEvent e) {
-      AddWildcardBreakpointDialog dialog = new AddWildcardBreakpointDialog(myProject);
-      dialog.show();
-      if (!dialog.isOK()) {
-        return;
-      }
-      final WildcardMethodBreakpoint methodBreakpoint = DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().addMethodBreakpoint(dialog.getClassPattern(), dialog.getMethodName());
-      if (methodBreakpoint != null) {
-        getPanel().addBreakpoint(methodBreakpoint);
-      }
-    }
+  public WildcardMethodBreakpoint addBreakpoint(Project project) {
+    AddWildcardBreakpointDialog dialog = new AddWildcardBreakpointDialog(project);
+    dialog.show();
+    WildcardMethodBreakpoint methodBreakpoint;
+    methodBreakpoint = !dialog.isOK()
+                       ? null
+                       : DebuggerManagerEx.getInstanceEx(project).getBreakpointManager()
+                         .addMethodBreakpoint(dialog.getClassPattern(), dialog.getMethodName());
+    return methodBreakpoint;
   }
 }

java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/actions/AddAction.java

@@ -15,18 +15,28 @@
  */
 package com.intellij.debugger.ui.breakpoints.actions;
 
+import com.intellij.debugger.ui.breakpoints.Breakpoint;
+import com.intellij.debugger.ui.breakpoints.BreakpointFactory;
 import com.intellij.debugger.ui.breakpoints.BreakpointPanel;
 import com.intellij.ide.IdeBundle;
+import com.intellij.openapi.project.Project;
 
 import javax.swing.*;
+import java.awt.event.ActionEvent;
 import java.awt.event.KeyEvent;
 
 /**
  * @author Eugene Zhuravlev
  *         Date: May 25, 2005
- */public abstract class AddAction extends BreakpointPanelAction {
-  protected AddAction() {
+ */
+public class AddAction extends BreakpointPanelAction {
+  protected final Project myProject;
+  protected BreakpointFactory myBreakpointFactory;
+
+  public AddAction(BreakpointFactory breakpointFactory, Project project) {
     super(IdeBundle.message("button.add"));
+    myProject = project;
+    this.myBreakpointFactory = breakpointFactory;
   }
 
   public void setPanel(BreakpointPanel panel) {
@@ -36,4 +46,11 @@ import java.awt.event.KeyEvent;
 
   public void update() {
   }
+
+  public void actionPerformed(ActionEvent e) {
+    Breakpoint breakpoint = myBreakpointFactory.addBreakpoint(myProject);
+    if (breakpoint != null) {
+      getPanel().addBreakpoint(breakpoint);
+    }
+  }
 }

platform/lang-api/src/com/intellij/ui/popup/util/ItemWrapper.java

@@ -40,4 +40,6 @@ public interface ItemWrapper {
   String footerText();
 
   void updateDetailView(DetailView panel);
+
+  boolean allowedToRemove();
 }

platform/lang-impl/src/com/intellij/ide/bookmarks/BookmarkItem.java

@@ -118,4 +118,9 @@ public class BookmarkItem implements ItemWrapper {
 
     panel.navigateInPreviewEditor(file, positionToNavigate);
   }
+
+  @Override
+  public boolean allowedToRemove() {
+    return true;
+  }
 }

platform/lang-impl/src/com/intellij/ide/bookmarks/actions/BookmarksAction.java

@@ -119,11 +119,6 @@ public class BookmarksAction extends AnAction implements DumbAware, MasterDetail
     return BookmarkManager.getInstance(project).hasBookmarksWithMnemonics();
   }
 
-  @Override
-  public boolean allowedToRemoveItem(ItemWrapper item) {
-    return true;
-  }
-
   protected static class BookmarkInContextInfo {
     private final DataContext myDataContext;
     private final Project myProject;

platform/lang-impl/src/com/intellij/ui/popup/util/DetailViewImpl.java

@@ -127,6 +127,11 @@ public class DetailViewImpl extends JPanel implements DetailView {
 
   @Override
   public void setDetailPanel(JPanel panel) {
+    if (panel == myDetailPanel) return;
+
+    if (myDetailPanel != null) {
+      remove(myDetailPanel);
+    }
     myDetailPanel = panel;
     add(panel, BorderLayout.SOUTH);
   }

platform/lang-impl/src/com/intellij/ui/popup/util/MasterDetailPopupBuilder.java

@@ -191,7 +191,7 @@ public class MasterDetailPopupBuilder {
             DefaultListModel model = myList.getModel() instanceof DefaultListModel
                                      ? (DefaultListModel)myList.getModel()
                                      : (DefaultListModel)((FilteringListModel)myList.getModel()).getOriginalModel();
-            if (myDelegate.allowedToRemoveItem(item)) {
+            if (item.allowedToRemove()) {
               model.removeElement(item);
 
               if (model.getSize() > 0) {
@@ -241,8 +241,6 @@ public class MasterDetailPopupBuilder {
     void itemRemoved(ItemWrapper item, Project project);
 
     boolean hasItemsWithMnemonic(Project project);
-
-    boolean allowedToRemoveItem(ItemWrapper item);
   }
 
   public class ItemRenderer extends JPanel implements ListCellRenderer {

platform/xdebugger-api/src/com/intellij/xdebugger/breakpoints/ui/BreakpointItem.java

@@ -26,5 +26,5 @@ import com.intellij.ui.popup.util.ItemWrapper;
  * To change this template use File | Settings | File Templates.
  */
 public interface BreakpointItem extends ItemWrapper {
-
+  Object getBreakpoint();
 }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointItem.java

@@ -0,0 +1,92 @@
+/*
+ * 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.xdebugger.impl.breakpoints;
+
+import com.intellij.openapi.editor.LogicalPosition;
+import com.intellij.openapi.project.Project;
+import com.intellij.ui.ColoredListCellRenderer;
+import com.intellij.ui.popup.util.DetailView;
+import com.intellij.xdebugger.XSourcePosition;
+import com.intellij.xdebugger.breakpoints.XBreakpoint;
+import com.intellij.xdebugger.breakpoints.ui.BreakpointItem;
+import com.intellij.xdebugger.impl.breakpoints.ui.XBreakpointPropertiesPanel;
+
+import javax.swing.*;
+
+/**
+* Created with IntelliJ IDEA.
+* User: intendia
+* Date: 10.05.12
+* Time: 1:14
+* To change this template use File | Settings | File Templates.
+*/
+class XBreakpointItem implements BreakpointItem {
+  private final XBreakpoint<?> myBreakpoint;
+
+  public XBreakpointItem(XBreakpoint<?> breakpoint) {
+    myBreakpoint = breakpoint;
+  }
+
+  @Override
+  public void setupRenderer(ColoredListCellRenderer renderer, Project project, boolean selected) {
+    renderer.setIcon(((XBreakpointBase)myBreakpoint).getIcon());
+  }
+
+  @Override
+  public void updateMnemonicLabel(JLabel label) {
+    //To change body of implemented methods use File | Settings | File Templates.
+  }
+
+  @Override
+  public void execute(Project project) {
+    //To change body of implemented methods use File | Settings | File Templates.
+  }
+
+  @Override
+  public String speedSearchText() {
+    return ((XBreakpointBase)myBreakpoint).getType().getDisplayText(myBreakpoint);
+  }
+
+  @Override
+  public String footerText() {
+    return ((XBreakpointBase)myBreakpoint).getType().getDisplayText(myBreakpoint);
+  }
+
+  @Override
+  public void updateDetailView(DetailView panel) {
+    XSourcePosition sourcePosition = myBreakpoint.getSourcePosition();
+    if (sourcePosition != null) {
+      panel.navigateInPreviewEditor(sourcePosition.getFile(), new LogicalPosition(sourcePosition.getLine(), sourcePosition.getOffset()));
+    }
+
+    Project project = ((XBreakpointBase)myBreakpoint).getProject();
+
+    XBreakpointPropertiesPanel<XBreakpoint<?>> propertiesPanel =
+      new XBreakpointPropertiesPanel<XBreakpoint<?>>(project, ((XBreakpointBase)myBreakpoint).getBreakpointManager(), myBreakpoint);
+
+    panel.setDetailPanel(propertiesPanel.getMainPanel());
+  }
+
+  @Override
+  public boolean allowedToRemove() {
+    return false;  //To change body of implemented methods use File | Settings | File Templates.
+  }
+
+  @Override
+  public Object getBreakpoint() {
+    return myBreakpoint;
+  }
+}

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/XBreakpointPanelProvider.java

@@ -15,7 +15,8 @@
  */
 package com.intellij.xdebugger.impl.breakpoints;
 
-import com.intellij.openapi.editor.LogicalPosition;
+import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.intellij.openapi.editor.markup.GutterIconRenderer;
 import com.intellij.openapi.editor.markup.RangeHighlighter;
 import com.intellij.openapi.project.Project;
@@ -23,26 +24,19 @@ import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.ui.ColoredListCellRenderer;
-import com.intellij.ui.popup.util.DetailView;
-import com.intellij.xdebugger.XSourcePosition;
 import com.intellij.xdebugger.breakpoints.*;
 import com.intellij.xdebugger.XDebuggerManager;
 import com.intellij.xdebugger.XDebuggerUtil;
 import com.intellij.xdebugger.breakpoints.ui.BreakpointItem;
-import com.intellij.xdebugger.impl.breakpoints.XBreakpointBase;
-import com.intellij.xdebugger.impl.breakpoints.XBreakpointUtil;
-import com.intellij.xdebugger.impl.breakpoints.XLineBreakpointImpl;
 import com.intellij.xdebugger.impl.breakpoints.ui.AbstractBreakpointPanel;
 import com.intellij.xdebugger.impl.breakpoints.ui.BreakpointPanelProvider;
-import com.intellij.xdebugger.impl.breakpoints.ui.XBreakpointPropertiesPanel;
 import com.intellij.xdebugger.impl.breakpoints.ui.XBreakpointsPanel;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import javax.swing.*;
 import java.util.Collection;
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * @author nik
@@ -95,6 +89,17 @@ public class XBreakpointPanelProvider extends BreakpointPanelProvider<XBreakpoin
     return panels;
   }
 
+  @Override
+  public AnAction[] getAddBreakpointActions(@NotNull Project project) {
+    List<AnAction> result = new ArrayList<AnAction>();
+    for (XBreakpointType<?, ?> type : XBreakpointUtil.getBreakpointTypes()) {
+      if (type.isAddBreakpointButtonVisible()) {
+        result.add(new AddXBreakpointAction(type));
+      }
+    }
+    return new AnAction[0];
+  }
+
   private static <B extends XBreakpoint<?>> XBreakpointsPanel<B> createBreakpointsPanel(final Project project, DialogWrapper parentDialog, final XBreakpointType<B, ?> type) {
     return new XBreakpointsPanel<B>(project, parentDialog, type);
   }
@@ -106,51 +111,23 @@ public class XBreakpointPanelProvider extends BreakpointPanelProvider<XBreakpoin
   public void provideBreakpointItems(Project project, Collection<BreakpointItem> items) {
     XBreakpoint<?>[] allBreakpoints = XDebuggerManager.getInstance(project).getBreakpointManager().getAllBreakpoints();
     for (XBreakpoint<?> breakpoint : allBreakpoints) {
-      createBreakpointItem(breakpoint);
+      items.add(new XBreakpointItem(breakpoint));
     }
   }
 
-  private BreakpointItem createBreakpointItem(final XBreakpoint<?> breakpoint) {
-    return new BreakpointItem() {
-      @Override
-      public void setupRenderer(ColoredListCellRenderer renderer, Project project, boolean selected) {
-        renderer.setIcon(((XBreakpointBase)breakpoint).getIcon());
-      }
+  private class AddXBreakpointAction extends AnAction {
 
-      @Override
-      public void updateMnemonicLabel(JLabel label) {
-        //To change body of implemented methods use File | Settings | File Templates.
-      }
+    private XBreakpointType<?, ?> myType;
 
-      @Override
-      public void execute(Project project) {
-        //To change body of implemented methods use File | Settings | File Templates.
-      }
+    public AddXBreakpointAction(XBreakpointType<?, ?> type) {
+      myType = type;
+      getTemplatePresentation().setIcon(type.getEnabledIcon());
+      getTemplatePresentation().setText(type.getTitle());
+    }
 
-      @Override
-      public String speedSearchText() {
-        return ((XBreakpointBase)breakpoint).getType().getDisplayText(breakpoint);
-      }
-
-      @Override
-      public String footerText() {
-        return ((XBreakpointBase)breakpoint).getType().getDisplayText(breakpoint);
-      }
-
-      @Override
-      public void updateDetailView(DetailView panel) {
-        XSourcePosition sourcePosition = breakpoint.getSourcePosition();
-        if (sourcePosition != null) {
-          panel.navigateInPreviewEditor(sourcePosition.getFile(), new LogicalPosition(sourcePosition.getLine(), sourcePosition.getOffset()));
-        }
-
-        Project project = ((XBreakpointBase)breakpoint).getProject();
-
-        XBreakpointPropertiesPanel<XBreakpoint<?>> propertiesPanel =
-          new XBreakpointPropertiesPanel<XBreakpoint<?>>(project, ((XBreakpointBase)breakpoint).getBreakpointManager(), breakpoint);
-
-        panel.setDetailPanel(propertiesPanel.getMainPanel());
-      }
-    };
+    @Override
+    public void actionPerformed(AnActionEvent e) {
+      myType.addBreakpoint(getEventProject(e), null);
+    }
   }
 }

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/ui/BreakpointPanelProvider.java

@@ -15,6 +15,7 @@
  */
 package com.intellij.xdebugger.impl.breakpoints.ui;
 
+import com.intellij.openapi.actionSystem.AnAction;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.markup.GutterIconRenderer;
 import com.intellij.openapi.project.Project;
@@ -40,6 +41,8 @@ public abstract class BreakpointPanelProvider<B> {
   @NotNull
   public abstract Collection<AbstractBreakpointPanel<B>> getBreakpointPanels(@NotNull Project project, @NotNull DialogWrapper parentDialog);
 
+  public abstract AnAction[] getAddBreakpointActions(@NotNull Project project);
+
   public abstract void onDialogClosed(final Project project);
 
   public abstract void provideBreakpointItems(Project project, Collection<BreakpointItem> items);

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/ui/BreakpointsMasterDetailPopupFactory.java

@@ -15,16 +15,25 @@
  */
 package com.intellij.xdebugger.impl.breakpoints.ui;
 
-import com.intellij.ide.bookmarks.BookmarkManager;
+import com.intellij.ide.actions.ShowPopupMenuAction;
+import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
 import com.intellij.openapi.actionSystem.DefaultActionGroup;
 import com.intellij.openapi.components.ServiceManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.popup.JBPopup;
+import com.intellij.openapi.ui.popup.JBPopupFactory;
+import com.intellij.ui.AnActionButton;
 import com.intellij.ui.components.JBList;
 import com.intellij.ui.popup.util.ItemWrapper;
 import com.intellij.ui.popup.util.MasterDetailPopupBuilder;
+import com.intellij.util.PlatformIcons;
+import com.intellij.xdebugger.XDebuggerManager;
+import com.intellij.xdebugger.breakpoints.XBreakpoint;
+import com.intellij.xdebugger.breakpoints.XBreakpointListener;
 import com.intellij.xdebugger.breakpoints.ui.BreakpointItem;
 import com.intellij.xdebugger.impl.DebuggerSupport;
+import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import javax.swing.*;
@@ -66,7 +75,7 @@ public class BreakpointsMasterDetailPopupFactory {
     final JBList list = new JBList(model);
     list.getEmptyText().setText("No Bookmarks");
 
-    DefaultActionGroup actions = new DefaultActionGroup();
+    DefaultActionGroup actions = getActions();
 
     final JBPopup popup = new MasterDetailPopupBuilder(myProject).
       setActionsGroup(actions).
@@ -91,15 +100,30 @@ public class BreakpointsMasterDetailPopupFactory {
           return false;
         }
 
-        @Override
-        public boolean allowedToRemoveItem(ItemWrapper item) {
-          return false;
-        }
       }).createMasterDetailPopup();
 
     return popup;
   }
 
+  private DefaultActionGroup getActions() {
+    DefaultActionGroup actions = new DefaultActionGroup();
+    final DefaultActionGroup breakpointTypes = new DefaultActionGroup();
+    for (BreakpointPanelProvider provider : myBreakpointPanelProviders) {
+      breakpointTypes.addAll(provider.getAddBreakpointActions(myProject));
+    }
+    actions.add(new AnAction("Add Breakpoint", null, PlatformIcons.ADD_ICON) {
+      @Override
+      public void actionPerformed(AnActionEvent e) {
+
+        JBPopupFactory.getInstance()
+          .createActionGroupPopup("Choose type", breakpointTypes, e.getDataContext(), JBPopupFactory.ActionSelectionAid.NUMBERING, false)
+          .showInFocusCenter();
+      }
+    });
+
+    return actions;
+  }
+
   private DefaultListModel createBreakpointsItemsList() {
     DefaultListModel model = new DefaultListModel();
     ArrayList<BreakpointItem> items = new ArrayList<BreakpointItem>();

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/ui/XAddBreakpointAction.java

@@ -25,8 +25,8 @@ import java.util.Collection;
 /**
  * @author nik
  */
-public class AddBreakpointAction<B extends XBreakpoint<?>> extends XBreakpointPanelAction<B> {
-  public AddBreakpointAction(final XBreakpointsPanel<B> breakpointsPanel) {
+public class XAddBreakpointAction<B extends XBreakpoint<?>> extends XBreakpointPanelAction<B> {
+  public XAddBreakpointAction(final XBreakpointsPanel<B> breakpointsPanel) {
     super(breakpointsPanel, XDebuggerBundle.message("xbreakpoints.dialog.button.add"));
   }
 

platform/xdebugger-impl/src/com/intellij/xdebugger/impl/breakpoints/ui/XBreakpointsPanel.java

@@ -80,7 +80,7 @@ public class XBreakpointsPanel<B extends XBreakpoint<?>> extends AbstractBreakpo
 
     List<XBreakpointPanelAction<B>> actions = new ArrayList<XBreakpointPanelAction<B>>();
     if (type.isAddBreakpointButtonVisible()) {
-      actions.add(new AddBreakpointAction<B>(this));
+      actions.add(new XAddBreakpointAction<B>(this));
     }
     actions.add(new GoToBreakpointAction<B>(this, XDebuggerBundle.message("xbreakpoints.dialog.button.goto"), true));
     actions.add(new GoToBreakpointAction<B>(this, XDebuggerBundle.message("xbreakpoints.dialog.button.view.source"), false));