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 56e8cd383ee6..da86bac6e6a2 100644
--- a/java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java
+++ b/java/debugger/impl/src/com/intellij/debugger/engine/DebugProcessImpl.java
@@ -1477,7 +1477,6 @@ public abstract class DebugProcessImpl implements DebugProcess {
       applyThreadFilter(getContextThread());
       final SuspendContextImpl context = getSuspendContext();
       myRunToCursorBreakpoint.setSuspendPolicy(context.getSuspendPolicy() == EventRequest.SUSPEND_EVENT_THREAD? DebuggerSettings.SUSPEND_THREAD : DebuggerSettings.SUSPEND_ALL);
-      myRunToCursorBreakpoint.setLogEnabled(false);
       myRunToCursorBreakpoint.createRequest(context.getDebugProcess());
       DebugProcessImpl.this.myRunToCursorBreakpoint = myRunToCursorBreakpoint;
       super.contextAction();
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/Breakpoint.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/Breakpoint.java
index 8ea3fea6923d..8692fdcbfe5b 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/Breakpoint.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/Breakpoint.java
@@ -233,7 +233,7 @@ public abstract class Breakpoint<P extends JavaBreakpointProperties> implements
 
   private void runAction(final EvaluationContextImpl context, LocatableEvent event) {
     final DebugProcessImpl debugProcess = context.getDebugProcess();
-    if (myXBreakpoint.isLogMessage() || myXBreakpoint.getLogExpression() != null) {
+    if (isLogEnabled() || isLogExpressionEnabled()) {
       final StringBuilder buf = StringBuilderSpinAllocator.alloc();
       try {
         if (myXBreakpoint.isLogMessage()) {
@@ -449,7 +449,7 @@ public abstract class Breakpoint<P extends JavaBreakpointProperties> implements
     myXBreakpoint.setEnabled(enabled);
   }
 
-  public boolean isLogEnabled() {
+  protected boolean isLogEnabled() {
     return myXBreakpoint.isLogMessage();
   }
 
@@ -457,11 +457,11 @@ public abstract class Breakpoint<P extends JavaBreakpointProperties> implements
     myXBreakpoint.setLogMessage(logEnabled);
   }
 
-  public boolean isLogExpressionEnabled() {
+  protected boolean isLogExpressionEnabled() {
     return myXBreakpoint.getLogExpression() != null;
   }
 
-  public void setLogExpressionEnabled(boolean LOG_EXPRESSION_ENABLED) {
+  protected void setLogExpressionEnabled(boolean LOG_EXPRESSION_ENABLED) {
   }
 
   @Override
@@ -504,7 +504,7 @@ public abstract class Breakpoint<P extends JavaBreakpointProperties> implements
     return myXBreakpoint.getProperties().getClassExclusionFilters();
   }
 
-  public void setClassExclusionFilters(ClassFilter[] filters) {
+  protected void setClassExclusionFilters(ClassFilter[] filters) {
     myXBreakpoint.getProperties().setClassExclusionFilters(filters);
   }
 
@@ -526,7 +526,7 @@ public abstract class Breakpoint<P extends JavaBreakpointProperties> implements
     myXBreakpoint.getProperties().setInstanceFilters(filters);
   }
 
-  public static String getSuspendPolicy(XBreakpoint breakpoint) {
+  private static String getSuspendPolicy(XBreakpoint breakpoint) {
     switch (breakpoint.getSuspendPolicy()) {
       case ALL:
         return DebuggerSettings.SUSPEND_ALL;
@@ -540,7 +540,7 @@ public abstract class Breakpoint<P extends JavaBreakpointProperties> implements
     }
   }
 
-  public static SuspendPolicy transformSuspendPolicy(String policy) {
+  private static SuspendPolicy transformSuspendPolicy(String policy) {
     if (DebuggerSettings.SUSPEND_ALL.equals(policy)) {
       return SuspendPolicy.ALL;
     } else if (DebuggerSettings.SUSPEND_THREAD.equals(policy)) {
@@ -552,7 +552,7 @@ public abstract class Breakpoint<P extends JavaBreakpointProperties> implements
     }
   }
 
-  public boolean isSuspend() {
+  protected boolean isSuspend() {
     return myXBreakpoint.getSuspendPolicy() != SuspendPolicy.NONE;
   }
 
@@ -565,11 +565,11 @@ public abstract class Breakpoint<P extends JavaBreakpointProperties> implements
     myXBreakpoint.setSuspendPolicy(transformSuspendPolicy(policy));
   }
 
-  public void setLogMessage(TextWithImports logMessage) {
+  protected void setLogMessage(TextWithImports logMessage) {
     myXBreakpoint.setLogExpression(logMessage.getText());
   }
 
-  public boolean isConditionEnabled() {
+  protected boolean isConditionEnabled() {
     return myXBreakpoint.getCondition() != null && !myXBreakpoint.getCondition().isEmpty();
   }
 
@@ -577,7 +577,7 @@ public abstract class Breakpoint<P extends JavaBreakpointProperties> implements
     myXBreakpoint.setCondition(condition);
   }
 
-  public void addInstanceFilter(long l) {
+  protected void addInstanceFilter(long l) {
     myXBreakpoint.getProperties().addInstanceFilter(l);
   }
 }
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointManager.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointManager.java
index 8e9282747729..929c3133afde 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointManager.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointManager.java
@@ -30,7 +30,9 @@ import com.intellij.debugger.impl.DebuggerContextListener;
 import com.intellij.debugger.impl.DebuggerManagerImpl;
 import com.intellij.debugger.impl.DebuggerSession;
 import com.intellij.debugger.ui.JavaDebuggerSupport;
+import com.intellij.openapi.application.AccessToken;
 import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.application.WriteAction;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
@@ -43,22 +45,20 @@ import com.intellij.openapi.ui.MessageType;
 import com.intellij.openapi.util.Comparing;
 import com.intellij.openapi.util.Key;
 import com.intellij.openapi.util.TextRange;
+import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiField;
 import com.intellij.psi.PsiFile;
 import com.intellij.util.Alarm;
 import com.intellij.util.EventDispatcher;
 import com.intellij.xdebugger.XDebuggerManager;
-import com.intellij.xdebugger.breakpoints.XBreakpoint;
-import com.intellij.xdebugger.breakpoints.XBreakpointListener;
-import com.intellij.xdebugger.breakpoints.XBreakpointManager;
+import com.intellij.xdebugger.XDebuggerUtil;
+import com.intellij.xdebugger.breakpoints.*;
 import com.intellij.xdebugger.impl.DebuggerSupport;
 import com.intellij.xdebugger.impl.XDebugSessionImpl;
 import com.intellij.xdebugger.impl.breakpoints.XBreakpointManagerImpl;
 import com.intellij.xdebugger.impl.breakpoints.XDependentBreakpointManager;
-import com.sun.jdi.Field;
 import com.sun.jdi.InternalException;
-import com.sun.jdi.ObjectReference;
 import com.sun.jdi.ThreadReference;
 import com.sun.jdi.request.*;
 import gnu.trove.TIntHashSet;
@@ -66,6 +66,7 @@ import org.jdom.Element;
 import org.jetbrains.annotations.NonNls;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.jetbrains.java.debugger.breakpoints.properties.JavaExceptionBreakpointProperties;
 
 import javax.swing.*;
 import java.util.*;
@@ -81,7 +82,6 @@ public class BreakpointManager {
   @NonNls private static final String RULES_GROUP_NAME = "breakpoint_rules";
 
   private final Project myProject;
-  private XBreakpointManager myXBreakpointManager;
   private final Map<XBreakpoint, Breakpoint> myBreakpoints = new HashMap<XBreakpoint, Breakpoint>(); // breakpoints storage, access should be synchronized
   @Nullable private List<Breakpoint> myBreakpointsListForIteration = null; // another list for breakpoints iteration, unsynchronized access ok
   private final Map<String, String> myUIProperties = new LinkedHashMap<String, String>();
@@ -141,8 +141,8 @@ public class BreakpointManager {
   }
 
   public void init() {
-    myXBreakpointManager = XDebuggerManager.getInstance(myProject).getBreakpointManager();
-    myXBreakpointManager.addBreakpointListener(new XBreakpointListener() {
+    XBreakpointManager manager = XDebuggerManager.getInstance(myProject).getBreakpointManager();
+    manager.addBreakpointListener(new XBreakpointListener() {
       @Override
       public void breakpointAdded(@NotNull XBreakpoint xBreakpoint) {
         if (isJavaType(xBreakpoint)) {
@@ -169,6 +169,10 @@ public class BreakpointManager {
     });
   }
 
+  private XBreakpointManager getXBreakpointManager() {
+    return XDebuggerManager.getInstance(myProject).getBreakpointManager();
+  }
+
   public void editBreakpoint(final Breakpoint breakpoint, final Editor editor) {
     DebuggerInvocationUtil.swingInvokeLater(myProject, new Runnable() {
       @Override
@@ -202,7 +206,7 @@ public class BreakpointManager {
 
   @Nullable
   public RunToCursorBreakpoint addRunToCursorBreakpoint(Document document, int lineIndex, final boolean ignoreBreakpoints) {
-    return RunToCursorBreakpoint.create(myProject, document, lineIndex, ignoreBreakpoints, null);
+    return RunToCursorBreakpoint.create(myProject, document, lineIndex, ignoreBreakpoints);
   }
 
   @Nullable
@@ -216,8 +220,8 @@ public class BreakpointManager {
     if (!LineBreakpoint.canAddLineBreakpoint(myProject, document, lineIndex)) {
       return null;
     }
-
-    LineBreakpoint breakpoint = LineBreakpoint.create(myProject, document, lineIndex, null);
+    XLineBreakpoint xLineBreakpoint = addXLineBreakpoint(JavaLineBreakpointType.class, document, lineIndex);
+    LineBreakpoint breakpoint = LineBreakpoint.create(myProject, xLineBreakpoint);
     if (breakpoint == null) {
       return null;
     }
@@ -226,15 +230,15 @@ public class BreakpointManager {
     return breakpoint;
   }
 
-  @Nullable
-  public FieldBreakpoint addFieldBreakpoint(Field field, ObjectReference object) {
-    ApplicationManager.getApplication().assertIsDispatchThread();
-    final FieldBreakpoint fieldBreakpoint = FieldBreakpoint.create(myProject, field, object, null);
-    if (fieldBreakpoint != null) {
-      addBreakpoint(fieldBreakpoint);
-    }
-    return fieldBreakpoint;
-  }
+  //@Nullable
+  //public FieldBreakpoint addFieldBreakpoint(Field field, ObjectReference object) {
+  //  ApplicationManager.getApplication().assertIsDispatchThread();
+  //  final FieldBreakpoint fieldBreakpoint = FieldBreakpoint.create(myProject, field, object, null);
+  //  if (fieldBreakpoint != null) {
+  //    addBreakpoint(fieldBreakpoint);
+  //  }
+  //  return fieldBreakpoint;
+  //}
 
   @Nullable
   public FieldBreakpoint addFieldBreakpoint(@NotNull Document document, int offset) {
@@ -255,7 +259,8 @@ public class BreakpointManager {
   @Nullable
   public FieldBreakpoint addFieldBreakpoint(Document document, int lineIndex, String fieldName) {
     ApplicationManager.getApplication().assertIsDispatchThread();
-    FieldBreakpoint fieldBreakpoint = FieldBreakpoint.create(myProject, document, lineIndex, fieldName, null);
+    XLineBreakpoint xBreakpoint = addXLineBreakpoint(JavaFieldBreakpointType.class, document, lineIndex);
+    FieldBreakpoint fieldBreakpoint = FieldBreakpoint.create(myProject, fieldName, xBreakpoint);
     if (fieldBreakpoint != null) {
       addBreakpoint(fieldBreakpoint);
     }
@@ -265,19 +270,28 @@ public class BreakpointManager {
   @NotNull
   public ExceptionBreakpoint addExceptionBreakpoint(@NotNull String exceptionClassName, String packageName) {
     ApplicationManager.getApplication().assertIsDispatchThread();
-    ExceptionBreakpoint breakpoint = new ExceptionBreakpoint(myProject, exceptionClassName, packageName, null);
-    addBreakpoint(breakpoint);
-    if (LOG.isDebugEnabled()) {
-      LOG.debug("ExceptionBreakpoint Added");
+    JavaExceptionBreakpointType type = (JavaExceptionBreakpointType)XDebuggerUtil.getInstance().findBreakpointType(JavaExceptionBreakpointType.class);
+    AccessToken token = WriteAction.start();
+    try {
+      XBreakpoint<JavaExceptionBreakpointProperties> xBreakpoint = XDebuggerManager.getInstance(myProject).getBreakpointManager()
+        .addBreakpoint(type, new JavaExceptionBreakpointProperties(exceptionClassName, packageName));
+      ExceptionBreakpoint breakpoint = new ExceptionBreakpoint(myProject, exceptionClassName, packageName, xBreakpoint);
+      addBreakpoint(breakpoint);
+      if (LOG.isDebugEnabled()) {
+        LOG.debug("ExceptionBreakpoint Added");
+      }
+      return breakpoint;
+    } finally {
+      token.finish();
     }
-    return breakpoint;
   }
 
   @Nullable
   public MethodBreakpoint addMethodBreakpoint(Document document, int lineIndex) {
     ApplicationManager.getApplication().assertIsDispatchThread();
 
-    MethodBreakpoint breakpoint = MethodBreakpoint.create(myProject, document, lineIndex, null);
+    XLineBreakpoint xBreakpoint = addXLineBreakpoint(JavaMethodBreakpointType.class, document, lineIndex);
+    MethodBreakpoint breakpoint = MethodBreakpoint.create(myProject, xBreakpoint);
     if (breakpoint == null) {
       return null;
     }
@@ -288,6 +302,19 @@ public class BreakpointManager {
     return breakpoint;
   }
 
+  private <B extends XBreakpoint<?>> XLineBreakpoint addXLineBreakpoint(Class<? extends XBreakpointType<B,?>> typeCls, Document document, int lineIndex) {
+    XBreakpointType<B, ?> type = XDebuggerUtil.getInstance().findBreakpointType(typeCls);
+    VirtualFile file = FileDocumentManager.getInstance().getFile(document);
+    AccessToken token = WriteAction.start();
+    try {
+      return XDebuggerManager.getInstance(myProject).getBreakpointManager()
+        .addLineBreakpoint((XLineBreakpointType)type, file.getUrl(), lineIndex,
+                           ((XLineBreakpointType)type).createBreakpointProperties(file, lineIndex));
+    } finally {
+      token.finish();
+    }
+  }
+
   @Nullable
   public WildcardMethodBreakpoint addMethodBreakpoint(String classPattern, String methodName) {
     ApplicationManager.getApplication().assertIsDispatchThread();
@@ -489,8 +516,12 @@ public class BreakpointManager {
     if (breakpoint == null) {
       return;
     }
-
-    myXBreakpointManager.removeBreakpoint(breakpoint.myXBreakpoint);
+    AccessToken token = WriteAction.start();
+    try {
+      getXBreakpointManager().removeBreakpoint(breakpoint.myXBreakpoint);
+    } finally {
+      token.finish();
+    }
   }
 
   private synchronized void onBreakpointRemoved(@Nullable final XBreakpoint xBreakpoint) {
@@ -629,7 +660,7 @@ public class BreakpointManager {
     if (myBreakpointsListForIteration == null) {
       myBreakpointsListForIteration = new ArrayList<Breakpoint>(myBreakpoints.size());
 
-      for (XBreakpoint<?> xBreakpoint : myXBreakpointManager.getAllBreakpoints()) {
+      for (XBreakpoint<?> xBreakpoint : getXBreakpointManager().getAllBreakpoints()) {
         if (isJavaType(xBreakpoint)) {
           Breakpoint breakpoint = myBreakpoints.get(xBreakpoint);
           if (breakpoint == null) {
@@ -857,7 +888,7 @@ public class BreakpointManager {
 
   // copied from XDebugSessionImpl processDependencies
   public void processBreakpointHit(@NotNull final Breakpoint breakpoint) {
-    XDependentBreakpointManager dependentBreakpointManager = ((XBreakpointManagerImpl)myXBreakpointManager).getDependentBreakpointManager();
+    XDependentBreakpointManager dependentBreakpointManager = ((XBreakpointManagerImpl)getXBreakpointManager()).getDependentBreakpointManager();
     XBreakpoint xBreakpoint = findXBreakpoint(breakpoint);
     if (!dependentBreakpointManager.isMasterOrSlave(xBreakpoint)) {
       return;
@@ -901,7 +932,7 @@ public class BreakpointManager {
   
   @Nullable
   public Breakpoint findMasterBreakpoint(@NotNull Breakpoint dependentBreakpoint) {
-    XDependentBreakpointManager dependentBreakpointManager = ((XBreakpointManagerImpl)myXBreakpointManager).getDependentBreakpointManager();
+    XDependentBreakpointManager dependentBreakpointManager = ((XBreakpointManagerImpl)getXBreakpointManager()).getDependentBreakpointManager();
     XBreakpoint xBreakpoint = findXBreakpoint(dependentBreakpoint);
     return myBreakpoints.get(dependentBreakpointManager.getMasterBreakpoint(xBreakpoint));
   }
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointPropertiesPanel.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointPropertiesPanel.java
index 38031d4735a6..ad9d5c93a47a 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointPropertiesPanel.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointPropertiesPanel.java
@@ -462,126 +462,126 @@ public abstract class BreakpointPropertiesPanel {
    * Init UI components with the values from Breakpoint
    */
   public void initFrom(Breakpoint breakpoint, boolean moreOptionsVisible1) {
-    myBreakpoint = breakpoint;
-    boolean moreOptionsVisible = moreOptionsVisible1;
-    boolean actionsPanelVisible = moreOptionsVisible1;
-
-    initMasterBreakpointPanel();
-
-    if (breakpoint.getCountFilter() > 0) {
-      myPassCountField.setText(Integer.toString(breakpoint.getCountFilter()));
-      moreOptionsVisible = true;
-    }
-    else {
-      myPassCountField.setText("");
-    }
-
-    PsiElement context = breakpoint.getEvaluationElement();
-    myPassCountCheckbox.setSelected(breakpoint.isCountFilterEnabled());
-
-    myConditionCheckbox.setSelected(breakpoint.isConditionEnabled());
-
-    myConditionCombo.setEnabled(breakpoint.isConditionEnabled());
-
-    myConditionCombo.setContext(context);
-    myConditionCombo.setText(breakpoint.getCondition() != null ? breakpoint.getCondition() : emptyText());
-
-    myCbSuspend.setSelected(breakpoint.isSuspend());
-    myRbSuspendThread.setEnabled(myCbSuspend.isSelected());
-    myRbSuspendAll.setEnabled(myCbSuspend.isSelected());
-
-    if(!breakpoint.isSuspend()) {
-      actionsPanelVisible = true;
-    }
-    if(DebuggerSettings.SUSPEND_THREAD.equals(breakpoint.getSuspendPolicy())){
-      myRbSuspendThread.setSelected(true);
-    }
-    else {
-      myRbSuspendAll.setSelected(true);
-    }
-
-    myCbSuspend.addActionListener(new ActionListener() {
-      @Override
-      public void actionPerformed(ActionEvent event) {
-        if (!myActionsPanel.isVisible()) {
-          if (!myCbSuspend.isSelected()) {
-            if (myDelegate != null) {
-              myDelegate.showActionsPanel();
-            }
-          }
-        }
-        myRbSuspendThread.setEnabled(myCbSuspend.isSelected());
-        myRbSuspendAll.setEnabled(myCbSuspend.isSelected());
-      }
-    });
-    myLogMessageCheckBox.setSelected(breakpoint.isLogEnabled());
-    myTemporaryCheckBox.setSelected(breakpoint.isRemoveAfterHit());
-    myEnabledCheckbox.setSelected(breakpoint.isEnabled());
-    myEnabledCheckbox.setText(breakpoint.getShortName() + " enabled");
-
-    DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().addBreakpointManagerListener(new BreakpointManagerListener() {
-      @Override
-      public void breakpointsChanged() {
-        myEnabledCheckbox.setSelected(myBreakpoint.isEnabled());
-      }
-    });
-
-    myEnabledCheckbox.addActionListener(new ActionListener() {
-      @Override
-      public void actionPerformed(ActionEvent event) {
-        if (myBreakpoint.isEnabled() != myEnabledCheckbox.isSelected()) {
-          myBreakpoint.setEnabled(myEnabledCheckbox.isSelected());
-          getBreakpointManager(myProject).fireBreakpointChanged(myBreakpoint);
-          myBreakpoint.updateUI();
-        }
-      }
-    });
-    myTemporaryCheckBox.setVisible(breakpoint instanceof LineBreakpoint);
-    myLogExpressionCheckBox.setSelected(breakpoint.isLogExpressionEnabled());
-    if (breakpoint.isLogEnabled() ||
-        breakpoint.isLogExpressionEnabled() || (breakpoint instanceof LineBreakpoint && breakpoint.isRemoveAfterHit())) {
-      actionsPanelVisible = true;
-    }
-
-    myLogExpressionCombo.setContext(context);
-
-    if (breakpoint.getLogMessage() != null) {
-      myLogExpressionCombo.setText(breakpoint.getLogMessage());
-    }
-    else {
-      myLogExpressionCombo.setText(emptyText());
-    }
-
-    myLogExpressionCombo.setEnabled(breakpoint.isLogExpressionEnabled());
-    if (breakpoint.isLogExpressionEnabled()) {
-      actionsPanelVisible = true;
-    }
-
-    myInstanceFiltersCheckBox.setSelected(breakpoint.isInstanceFiltersEnabled());
-    myInstanceFiltersField.setEnabled(breakpoint.isInstanceFiltersEnabled());
-    myInstanceFiltersField.getTextField().setEditable(breakpoint.isInstanceFiltersEnabled());
-    myInstanceFilters = breakpoint.getInstanceFilters();
-    updateInstanceFilterEditor(true);
-    if (breakpoint.isInstanceFiltersEnabled()) {
-      moreOptionsVisible = true;
-    }
-
-    myClassFiltersCheckBox.setSelected(breakpoint.isClassFiltersEnabled());
-    myClassFiltersField.setEnabled(breakpoint.isClassFiltersEnabled());
-    myClassFiltersField.getTextField().setEditable(breakpoint.isClassFiltersEnabled());
-    myClassFilters = breakpoint.getClassFilters();
-    myClassExclusionFilters = breakpoint.getClassExclusionFilters();
-    updateClassFilterEditor(true);
-    if (breakpoint.isClassFiltersEnabled()) {
-      moreOptionsVisible = true;
-    }
-
-    myBreakpointPsiClass = breakpoint.getPsiClass();
-
-    updateCheckboxes();
-
-    setActionsPanelVisible(actionsPanelVisible && !moreOptionsVisible1);
-    setMoreOptionsVisible(moreOptionsVisible);
+    //myBreakpoint = breakpoint;
+    //boolean moreOptionsVisible = moreOptionsVisible1;
+    //boolean actionsPanelVisible = moreOptionsVisible1;
+    //
+    //initMasterBreakpointPanel();
+    //
+    //if (breakpoint.getCountFilter() > 0) {
+    //  myPassCountField.setText(Integer.toString(breakpoint.getCountFilter()));
+    //  moreOptionsVisible = true;
+    //}
+    //else {
+    //  myPassCountField.setText("");
+    //}
+    //
+    //PsiElement context = breakpoint.getEvaluationElement();
+    //myPassCountCheckbox.setSelected(breakpoint.isCountFilterEnabled());
+    //
+    //myConditionCheckbox.setSelected(breakpoint.isConditionEnabled());
+    //
+    //myConditionCombo.setEnabled(breakpoint.isConditionEnabled());
+    //
+    //myConditionCombo.setContext(context);
+    //myConditionCombo.setText(breakpoint.getCondition() != null ? breakpoint.getCondition() : emptyText());
+    //
+    //myCbSuspend.setSelected(breakpoint.isSuspend());
+    //myRbSuspendThread.setEnabled(myCbSuspend.isSelected());
+    //myRbSuspendAll.setEnabled(myCbSuspend.isSelected());
+    //
+    //if(!breakpoint.isSuspend()) {
+    //  actionsPanelVisible = true;
+    //}
+    //if(DebuggerSettings.SUSPEND_THREAD.equals(breakpoint.getSuspendPolicy())){
+    //  myRbSuspendThread.setSelected(true);
+    //}
+    //else {
+    //  myRbSuspendAll.setSelected(true);
+    //}
+    //
+    //myCbSuspend.addActionListener(new ActionListener() {
+    //  @Override
+    //  public void actionPerformed(ActionEvent event) {
+    //    if (!myActionsPanel.isVisible()) {
+    //      if (!myCbSuspend.isSelected()) {
+    //        if (myDelegate != null) {
+    //          myDelegate.showActionsPanel();
+    //        }
+    //      }
+    //    }
+    //    myRbSuspendThread.setEnabled(myCbSuspend.isSelected());
+    //    myRbSuspendAll.setEnabled(myCbSuspend.isSelected());
+    //  }
+    //});
+    //myLogMessageCheckBox.setSelected(breakpoint.isLogEnabled());
+    //myTemporaryCheckBox.setSelected(breakpoint.isRemoveAfterHit());
+    //myEnabledCheckbox.setSelected(breakpoint.isEnabled());
+    //myEnabledCheckbox.setText(breakpoint.getShortName() + " enabled");
+    //
+    //DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().addBreakpointManagerListener(new BreakpointManagerListener() {
+    //  @Override
+    //  public void breakpointsChanged() {
+    //    myEnabledCheckbox.setSelected(myBreakpoint.isEnabled());
+    //  }
+    //});
+    //
+    //myEnabledCheckbox.addActionListener(new ActionListener() {
+    //  @Override
+    //  public void actionPerformed(ActionEvent event) {
+    //    if (myBreakpoint.isEnabled() != myEnabledCheckbox.isSelected()) {
+    //      myBreakpoint.setEnabled(myEnabledCheckbox.isSelected());
+    //      getBreakpointManager(myProject).fireBreakpointChanged(myBreakpoint);
+    //      myBreakpoint.updateUI();
+    //    }
+    //  }
+    //});
+    //myTemporaryCheckBox.setVisible(breakpoint instanceof LineBreakpoint);
+    //myLogExpressionCheckBox.setSelected(breakpoint.isLogExpressionEnabled());
+    //if (breakpoint.isLogEnabled() ||
+    //    breakpoint.isLogExpressionEnabled() || (breakpoint instanceof LineBreakpoint && breakpoint.isRemoveAfterHit())) {
+    //  actionsPanelVisible = true;
+    //}
+    //
+    //myLogExpressionCombo.setContext(context);
+    //
+    //if (breakpoint.getLogMessage() != null) {
+    //  myLogExpressionCombo.setText(breakpoint.getLogMessage());
+    //}
+    //else {
+    //  myLogExpressionCombo.setText(emptyText());
+    //}
+    //
+    //myLogExpressionCombo.setEnabled(breakpoint.isLogExpressionEnabled());
+    //if (breakpoint.isLogExpressionEnabled()) {
+    //  actionsPanelVisible = true;
+    //}
+    //
+    //myInstanceFiltersCheckBox.setSelected(breakpoint.isInstanceFiltersEnabled());
+    //myInstanceFiltersField.setEnabled(breakpoint.isInstanceFiltersEnabled());
+    //myInstanceFiltersField.getTextField().setEditable(breakpoint.isInstanceFiltersEnabled());
+    //myInstanceFilters = breakpoint.getInstanceFilters();
+    //updateInstanceFilterEditor(true);
+    //if (breakpoint.isInstanceFiltersEnabled()) {
+    //  moreOptionsVisible = true;
+    //}
+    //
+    //myClassFiltersCheckBox.setSelected(breakpoint.isClassFiltersEnabled());
+    //myClassFiltersField.setEnabled(breakpoint.isClassFiltersEnabled());
+    //myClassFiltersField.getTextField().setEditable(breakpoint.isClassFiltersEnabled());
+    //myClassFilters = breakpoint.getClassFilters();
+    //myClassExclusionFilters = breakpoint.getClassExclusionFilters();
+    //updateClassFilterEditor(true);
+    //if (breakpoint.isClassFiltersEnabled()) {
+    //  moreOptionsVisible = true;
+    //}
+    //
+    //myBreakpointPsiClass = breakpoint.getPsiClass();
+    //
+    //updateCheckboxes();
+    //
+    //setActionsPanelVisible(actionsPanelVisible && !moreOptionsVisible1);
+    //setMoreOptionsVisible(moreOptionsVisible);
   }
 
   private void initMasterBreakpointPanel() {
@@ -636,41 +636,41 @@ public abstract class BreakpointPropertiesPanel {
    */
   public void saveTo(Breakpoint breakpoint) {
 
-    saveMasterBreakpoint();
-    try {
-      String text = myPassCountField.getText().trim();
-      breakpoint.setCountFilter(!text.isEmpty() ? Integer.parseInt(text) : 0);
-      if (breakpoint.getCountFilter() < 0) {
-        breakpoint.setCountFilter(0);
-      }
-    }
-    catch (Exception ignored) {
-    }
-
-    breakpoint.setCountFilterEnabled(breakpoint.getCountFilter() > 0 && myPassCountCheckbox.isSelected());
-    breakpoint.setCondition(myConditionCombo.getText().getText());
-    //breakpoint.setConditionEnabled(myConditionCheckbox.isSelected());
-    breakpoint.setLogMessage(myLogExpressionCombo.getText());
-    breakpoint.setLogExpressionEnabled(!breakpoint.getLogMessage().isEmpty() && myLogExpressionCheckBox.isSelected());
-    breakpoint.setLogEnabled(myLogMessageCheckBox.isSelected());
-    breakpoint.setEnabled(myEnabledCheckbox.isSelected());
-    breakpoint.setRemoveAfterHit(myTemporaryCheckBox.isSelected());
-    //breakpoint.setSuspend(myCbSuspend.isSelected());
-    breakpoint.setSuspendPolicy(getSelectedSuspendPolicy());
-    reloadInstanceFilters();
-    reloadClassFilters();
-    updateInstanceFilterEditor(true);
-    updateClassFilterEditor(true);
-
-    breakpoint.setInstanceFiltersEnabled(myInstanceFiltersField.getText().length() > 0 && myInstanceFiltersCheckBox.isSelected());
-    breakpoint.setClassFiltersEnabled(myClassFiltersField.getText().length() > 0 && myClassFiltersCheckBox.isSelected());
-    breakpoint.setClassFilters(myClassFilters);
-    breakpoint.setClassExclusionFilters(myClassExclusionFilters);
-    breakpoint.setInstanceFilters(myInstanceFilters);
-
-    myConditionCombo.addRecent(myConditionCombo.getText());
-    myLogExpressionCombo.addRecent(myLogExpressionCombo.getText());
-    breakpoint.updateUI();
+    //saveMasterBreakpoint();
+    //try {
+    //  String text = myPassCountField.getText().trim();
+    //  breakpoint.setCountFilter(!text.isEmpty() ? Integer.parseInt(text) : 0);
+    //  if (breakpoint.getCountFilter() < 0) {
+    //    breakpoint.setCountFilter(0);
+    //  }
+    //}
+    //catch (Exception ignored) {
+    //}
+    //
+    //breakpoint.setCountFilterEnabled(breakpoint.getCountFilter() > 0 && myPassCountCheckbox.isSelected());
+    //breakpoint.setCondition(myConditionCombo.getText().getText());
+    ////breakpoint.setConditionEnabled(myConditionCheckbox.isSelected());
+    //breakpoint.setLogMessage(myLogExpressionCombo.getText());
+    //breakpoint.setLogExpressionEnabled(!breakpoint.getLogMessage().isEmpty() && myLogExpressionCheckBox.isSelected());
+    //breakpoint.setLogEnabled(myLogMessageCheckBox.isSelected());
+    //breakpoint.setEnabled(myEnabledCheckbox.isSelected());
+    //breakpoint.setRemoveAfterHit(myTemporaryCheckBox.isSelected());
+    ////breakpoint.setSuspend(myCbSuspend.isSelected());
+    //breakpoint.setSuspendPolicy(getSelectedSuspendPolicy());
+    //reloadInstanceFilters();
+    //reloadClassFilters();
+    //updateInstanceFilterEditor(true);
+    //updateClassFilterEditor(true);
+    //
+    //breakpoint.setInstanceFiltersEnabled(myInstanceFiltersField.getText().length() > 0 && myInstanceFiltersCheckBox.isSelected());
+    //breakpoint.setClassFiltersEnabled(myClassFiltersField.getText().length() > 0 && myClassFiltersCheckBox.isSelected());
+    //breakpoint.setClassFilters(myClassFilters);
+    //breakpoint.setClassExclusionFilters(myClassExclusionFilters);
+    //breakpoint.setInstanceFilters(myInstanceFilters);
+    //
+    //myConditionCombo.addRecent(myConditionCombo.getText());
+    //myLogExpressionCombo.addRecent(myLogExpressionCombo.getText());
+    //breakpoint.updateUI();
   }
 
   private static String concatWithEx(List<String> s, String concator, int N, String NthConcator) {
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java
index 200e377b87f8..0c3178742a58 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/BreakpointWithHighlighter.java
@@ -34,14 +34,9 @@ import com.intellij.openapi.editor.impl.DocumentMarkupModel;
 import com.intellij.openapi.editor.markup.MarkupEditorFilterFactory;
 import com.intellij.openapi.editor.markup.RangeHighlighter;
 import com.intellij.openapi.editor.markup.TextAttributes;
-import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Computable;
-import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.Key;
-import com.intellij.openapi.util.WriteExternalException;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.vfs.VirtualFileManager;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiElement;
@@ -58,7 +53,6 @@ import com.intellij.xdebugger.breakpoints.XLineBreakpoint;
 import com.intellij.xdebugger.ui.DebuggerColors;
 import com.intellij.xml.util.XmlStringUtil;
 import com.sun.jdi.ReferenceType;
-import org.jdom.Element;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.java.debugger.breakpoints.properties.JavaBreakpointProperties;
@@ -215,7 +209,7 @@ public abstract class BreakpointWithHighlighter<P extends JavaBreakpointProperti
     return isPositionValid(myXBreakpoint.getSourcePosition());
   }
 
-  private static boolean isPositionValid(@Nullable final XSourcePosition sourcePosition) {
+  protected static boolean isPositionValid(@Nullable final XSourcePosition sourcePosition) {
     return ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
       @Override
       public Boolean compute() {
@@ -294,7 +288,7 @@ public abstract class BreakpointWithHighlighter<P extends JavaBreakpointProperti
   }
 
   @Override
-  public final void reload() {
+  public void reload() {
     ApplicationManager.getApplication().assertReadAccessAllowed();
     final XSourcePosition position = myXBreakpoint.getSourcePosition();
     try {
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/ExceptionBreakpoint.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/ExceptionBreakpoint.java
index 88a9a6ff329e..b85bf6dfce77 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/ExceptionBreakpoint.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/ExceptionBreakpoint.java
@@ -144,8 +144,8 @@ public class ExceptionBreakpoint extends Breakpoint<JavaExceptionBreakpointPrope
       return;
     }
     // trying to create a request
-    ExceptionRequest request = debugProcess.getRequestsManager().createExceptionRequest(this, refType, isNOTIFY_CAUGHT(),
-                                                                                        isNOTIFY_UNCAUGHT());
+    ExceptionRequest request = debugProcess.getRequestsManager().createExceptionRequest(this, refType, isNotifyCaught(),
+                                                                                        isNotifyUncaught());
     debugProcess.getRequestsManager().enableRequest(request);
     if (LOG.isDebugEnabled()) {
       if (refType != null) {
@@ -242,23 +242,23 @@ public class ExceptionBreakpoint extends Breakpoint<JavaExceptionBreakpointPrope
   //  setPackageName(packageName != null? packageName : calcPackageName(packageName));
   //}
 
-  public boolean isNOTIFY_CAUGHT() {
+  private boolean isNotifyCaught() {
     return getProperties().NOTIFY_CAUGHT;
   }
 
-  public boolean isNOTIFY_UNCAUGHT() {
+  private boolean isNotifyUncaught() {
     return getProperties().NOTIFY_UNCAUGHT;
   }
 
-  public String getQualifiedName() {
+  private String getQualifiedName() {
     return getProperties().myQualifiedName;
   }
 
-  public void setQualifiedName(String qualifiedName) {
+  private void setQualifiedName(String qualifiedName) {
     getProperties().myQualifiedName = qualifiedName;
   }
 
-  public void setPackageName(String packageName) {
+  private void setPackageName(String packageName) {
     getProperties().myPackageName = packageName;
   }
 }
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/FieldBreakpoint.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/FieldBreakpoint.java
index ada59099a2db..01b3e1408dcf 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/FieldBreakpoint.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/FieldBreakpoint.java
@@ -33,12 +33,9 @@ import com.intellij.icons.AllIcons;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.markup.RangeHighlighter;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Key;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.openapi.vfs.VirtualFileManager;
 import com.intellij.psi.*;
 import com.intellij.psi.util.PsiTreeUtil;
 import com.intellij.util.Processor;
@@ -56,7 +53,6 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.java.debugger.breakpoints.properties.JavaFieldBreakpointProperties;
 
 import javax.swing.*;
-import java.util.List;
 
 public class FieldBreakpoint extends BreakpointWithHighlighter<JavaFieldBreakpointProperties> {
   private static final Logger LOG = Logger.getInstance("#com.intellij.debugger.ui.breakpoints.FieldBreakpoint");
@@ -68,8 +64,8 @@ public class FieldBreakpoint extends BreakpointWithHighlighter<JavaFieldBreakpoi
     super(project, breakpoint);
   }
 
-  private FieldBreakpoint(Project project, RangeHighlighter highlighter, @NotNull String fieldName, XBreakpoint breakpoint) {
-    super(project, highlighter, breakpoint);
+  private FieldBreakpoint(Project project, @NotNull String fieldName, XBreakpoint breakpoint) {
+    super(project, breakpoint);
     setFieldName(fieldName);
   }
 
@@ -183,14 +179,14 @@ public class FieldBreakpoint extends BreakpointWithHighlighter<JavaFieldBreakpoi
         return;
       }
       RequestManagerImpl manager = debugProcess.getRequestsManager();
-      if (isWATCH_MODIFICATION() && vm.canWatchFieldModification()) {
+      if (isWatchModification() && vm.canWatchFieldModification()) {
         ModificationWatchpointRequest request = manager.createModificationWatchpointRequest(this, field);
         debugProcess.getRequestsManager().enableRequest(request);
         if (LOG.isDebugEnabled()) {
           LOG.debug("Modification request added");
         }
       }
-      if (isWATCH_ACCESS() && vm.canWatchFieldAccess()) {
+      if (isWatchAccess() && vm.canWatchFieldAccess()) {
         AccessWatchpointRequest request = manager.createAccessWatchpointRequest(this, field);
         debugProcess.getRequestsManager().enableRequest(request);
         if (LOG.isDebugEnabled()) {
@@ -283,8 +279,8 @@ public class FieldBreakpoint extends BreakpointWithHighlighter<JavaFieldBreakpoi
     return className != null && !className.isEmpty() ? className + "." + getFieldName() : getFieldName();
   }
 
-  public static FieldBreakpoint create(@NotNull Project project, @NotNull Document document, int lineIndex, String fieldName, XBreakpoint xBreakpoint) {
-    FieldBreakpoint breakpoint = new FieldBreakpoint(project, createHighlighter(project, document, lineIndex), fieldName, xBreakpoint);
+  public static FieldBreakpoint create(@NotNull Project project, String fieldName, XBreakpoint xBreakpoint) {
+    FieldBreakpoint breakpoint = new FieldBreakpoint(project, fieldName, xBreakpoint);
     return (FieldBreakpoint)breakpoint.init();
   }
 
@@ -304,39 +300,39 @@ public class FieldBreakpoint extends BreakpointWithHighlighter<JavaFieldBreakpoi
     return field == getPsiField();
   }
 
-  protected static FieldBreakpoint create(@NotNull Project project, @NotNull Field field, ObjectReference object, XBreakpoint xBreakpoint) {
-    String fieldName = field.name();
-    int line = 0;
-    Document document = null;
-    try {
-      List locations = field.declaringType().allLineLocations();
-      if(!locations.isEmpty()) {
-        Location location = (Location)locations.get(0);
-        line = location.lineNumber();
-        VirtualFile file = VirtualFileManager.getInstance().findFileByUrl(location.sourcePath());
-        if(file != null) {
-          PsiFile psiFile = PsiManager.getInstance(project).findFile(file);
-          if(psiFile != null) {
-            document = PsiDocumentManager.getInstance(project).getDocument(psiFile);
-          }
-        }
-      }
-    }
-    catch (AbsentInformationException e) {
-      LOG.debug(e);
-    }
-    catch (InternalError e) {
-      LOG.debug(e);
-    }
-
-    if(document == null) return null;
-
-    FieldBreakpoint fieldBreakpoint = new FieldBreakpoint(project, createHighlighter(project, document, line), fieldName, xBreakpoint);
-    if (!fieldBreakpoint.isStatic()) {
-      fieldBreakpoint.addInstanceFilter(object.uniqueID());
-    }
-    return (FieldBreakpoint)fieldBreakpoint.init();
-  }
+  //protected static FieldBreakpoint create(@NotNull Project project, @NotNull Field field, ObjectReference object, XBreakpoint xBreakpoint) {
+  //  String fieldName = field.name();
+  //  int line = 0;
+  //  Document document = null;
+  //  try {
+  //    List locations = field.declaringType().allLineLocations();
+  //    if(!locations.isEmpty()) {
+  //      Location location = (Location)locations.get(0);
+  //      line = location.lineNumber();
+  //      VirtualFile file = VirtualFileManager.getInstance().findFileByUrl(location.sourcePath());
+  //      if(file != null) {
+  //        PsiFile psiFile = PsiManager.getInstance(project).findFile(file);
+  //        if(psiFile != null) {
+  //          document = PsiDocumentManager.getInstance(project).getDocument(psiFile);
+  //        }
+  //      }
+  //    }
+  //  }
+  //  catch (AbsentInformationException e) {
+  //    LOG.debug(e);
+  //  }
+  //  catch (InternalError e) {
+  //    LOG.debug(e);
+  //  }
+  //
+  //  if(document == null) return null;
+  //
+  //  FieldBreakpoint fieldBreakpoint = new FieldBreakpoint(project, createHighlighter(project, document, line), fieldName, xBreakpoint);
+  //  if (!fieldBreakpoint.isStatic()) {
+  //    fieldBreakpoint.addInstanceFilter(object.uniqueID());
+  //  }
+  //  return (FieldBreakpoint)fieldBreakpoint.init();
+  //}
 
   public static PsiField findField(Project project, Document document, int offset) {
     PsiFile file = PsiDocumentManager.getInstance(project).getPsiFile(document);
@@ -387,15 +383,15 @@ public class FieldBreakpoint extends BreakpointWithHighlighter<JavaFieldBreakpoi
     return getPsiClass();
   }
 
-  public boolean isWATCH_MODIFICATION() {
+  private boolean isWatchModification() {
     return getProperties().WATCH_MODIFICATION;
   }
 
-  public boolean isWATCH_ACCESS() {
+  private boolean isWatchAccess() {
     return getProperties().WATCH_ACCESS;
   }
 
-  public void setFieldName(String fieldName) {
+  private void setFieldName(String fieldName) {
     getProperties().myFieldName = fieldName;
   }
 }
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaLineBreakpointType.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaLineBreakpointType.java
index 455d90dd38b6..91b270e4c4fb 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaLineBreakpointType.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/JavaLineBreakpointType.java
@@ -27,6 +27,7 @@ import com.intellij.xdebugger.breakpoints.ui.XBreakpointGroupingRule;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.java.debugger.breakpoints.properties.JavaBreakpointProperties;
+import org.jetbrains.java.debugger.breakpoints.properties.JavaLineBreakpointProperties;
 
 import javax.swing.*;
 import java.util.List;
@@ -70,13 +71,13 @@ public class JavaLineBreakpointType extends JavaLineBreakpointTypeBase<JavaBreak
   @Nullable
   @Override
   public JavaBreakpointProperties createProperties() {
-    return new JavaBreakpointProperties();
+    return new JavaLineBreakpointProperties();
   }
 
   @Nullable
   @Override
   public JavaBreakpointProperties createBreakpointProperties(@NotNull VirtualFile file, int line) {
-    return new JavaBreakpointProperties();
+    return new JavaLineBreakpointProperties();
   }
 
   @Override
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/LineBreakpoint.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/LineBreakpoint.java
index e9e78df92bdc..2b3239122373 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/LineBreakpoint.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/LineBreakpoint.java
@@ -79,10 +79,6 @@ public class LineBreakpoint extends BreakpointWithHighlighter {
     super(project, xBreakpoint);
   }
 
-  public LineBreakpoint(Project project, RangeHighlighter highlighter, XBreakpoint xBreakpoint) {
-    super(project, highlighter, xBreakpoint);
-  }
-
   @Override
   protected Icon getDisabledIcon(boolean isMuted) {
     final Breakpoint master = DebuggerManagerEx.getInstanceEx(myProject).getBreakpointManager().findMasterBreakpoint(this);
@@ -471,13 +467,8 @@ public class LineBreakpoint extends BreakpointWithHighlighter {
     return ContextUtil.getContextElement(getSourcePosition());
   }
 
-  public static LineBreakpoint create(@NotNull Project project, @NotNull Document document, int lineIndex, XBreakpoint xBreakpoint) {
-    final RangeHighlighter highlighter = createHighlighter(project, document, lineIndex);
-    if (highlighter == null) {
-      return null;
-    }
-
-    LineBreakpoint breakpoint = new LineBreakpoint(project, highlighter, xBreakpoint);
+  public static LineBreakpoint create(@NotNull Project project, XBreakpoint xBreakpoint) {
+    LineBreakpoint breakpoint = new LineBreakpoint(project, xBreakpoint);
     return (LineBreakpoint)breakpoint.init();
   }
 
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/MethodBreakpoint.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/MethodBreakpoint.java
index 3d7f1ff019a0..82a4e24f5da7 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/MethodBreakpoint.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/MethodBreakpoint.java
@@ -35,19 +35,13 @@ import com.intellij.icons.AllIcons;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.markup.RangeHighlighter;
-import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.project.IndexNotReadyException;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Computable;
 import com.intellij.openapi.util.Key;
-import com.intellij.openapi.util.Ref;
-import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.*;
-import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.util.Processor;
 import com.intellij.util.StringBuilderSpinAllocator;
 import com.intellij.util.text.CharArrayUtil;
-import com.intellij.xdebugger.XDebuggerUtil;
 import com.intellij.xdebugger.breakpoints.XBreakpoint;
 import com.sun.jdi.AbsentInformationException;
 import com.sun.jdi.Location;
@@ -148,7 +142,7 @@ public class MethodBreakpoint extends BreakpointWithHighlighter<JavaMethodBreakp
       }
 
       RequestManagerImpl requestManager = debugProcess.getRequestsManager();
-      if (isWATCH_ENTRY()) {
+      if (isWatchEntry()) {
         MethodEntryRequest entryRequest = (MethodEntryRequest)findRequest(debugProcess, MethodEntryRequest.class);
         if (entryRequest == null) {
           entryRequest = requestManager.createMethodEntryRequest(this);
@@ -161,7 +155,7 @@ public class MethodBreakpoint extends BreakpointWithHighlighter<JavaMethodBreakp
         entryRequest.addClassFilter(classType);
         debugProcess.getRequestsManager().enableRequest(entryRequest);
       }
-      if (isWATCH_EXIT()) {
+      if (isWatchExit()) {
         MethodExitRequest exitRequest = (MethodExitRequest)findRequest(debugProcess, MethodExitRequest.class);
         if (exitRequest == null) {
           exitRequest = requestManager.createMethodExitRequest(this);
@@ -293,8 +287,8 @@ public class MethodBreakpoint extends BreakpointWithHighlighter<JavaMethodBreakp
   }
 
   @Nullable
-  public static MethodBreakpoint create(@NotNull Project project, @NotNull Document document, int lineIndex, XBreakpoint xBreakpoint) {
-    final MethodBreakpoint breakpoint = new MethodBreakpoint(project, createHighlighter(project, document, lineIndex));
+  public static MethodBreakpoint create(@NotNull Project project, XBreakpoint xBreakpoint) {
+    final MethodBreakpoint breakpoint = new MethodBreakpoint(project, xBreakpoint);
     return (MethodBreakpoint)breakpoint.init();
   }
 
@@ -380,28 +374,28 @@ public class MethodBreakpoint extends BreakpointWithHighlighter<JavaMethodBreakp
     return false;
   }
 
-  public boolean isWATCH_ENTRY() {
+  private boolean isWatchEntry() {
     return getProperties().WATCH_ENTRY;
   }
 
-  public void setWATCH_ENTRY(boolean WATCH_ENTRY) {
+  private void setWatchEntry(boolean WATCH_ENTRY) {
     getProperties().WATCH_ENTRY = WATCH_ENTRY;
   }
 
-  public boolean isWATCH_EXIT() {
+  private boolean isWatchExit() {
     return getProperties().WATCH_EXIT;
   }
 
-  public void setWATCH_EXIT(boolean WATCH_EXIT) {
+  private void setWatchExit(boolean WATCH_EXIT) {
     getProperties().WATCH_EXIT = WATCH_EXIT;
   }
 
   @Nullable
-  public String getMethodName() {
+  private String getMethodName() {
     return getProperties().myMethodName;
   }
 
-  public void setMethodName(@Nullable String methodName) {
+  private void setMethodName(@Nullable String methodName) {
     getProperties().myMethodName = methodName;
   }
 
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/RunToCursorBreakpoint.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/RunToCursorBreakpoint.java
index a103ddcc2709..19a187da03c4 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/RunToCursorBreakpoint.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/RunToCursorBreakpoint.java
@@ -18,11 +18,11 @@ package com.intellij.debugger.ui.breakpoints;
 import com.intellij.debugger.SourcePosition;
 import com.intellij.debugger.engine.DebugProcessImpl;
 import com.intellij.openapi.editor.Document;
-import com.intellij.openapi.editor.markup.RangeHighlighter;
 import com.intellij.openapi.fileEditor.FileDocumentManager;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.xdebugger.breakpoints.XBreakpoint;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiManager;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -32,18 +32,11 @@ import org.jetbrains.annotations.Nullable;
  */
 public class RunToCursorBreakpoint extends LineBreakpoint {
   private final boolean myRestoreBreakpoints;
-  @Nullable
   private final SourcePosition myCustomPosition;
+  private String mySuspendPolicy;
 
-  protected RunToCursorBreakpoint(@NotNull Project project, @NotNull RangeHighlighter highlighter, boolean restoreBreakpoints, XBreakpoint xBreakpoint) {
-    super(project, highlighter, xBreakpoint);
-    setVisible(false);
-    myRestoreBreakpoints = restoreBreakpoints;
-    myCustomPosition = null;
-  }
-
-  protected RunToCursorBreakpoint(@NotNull Project project, @NotNull SourcePosition pos, boolean restoreBreakpoints, XBreakpoint xBreakpoint) {
-    super(project, xBreakpoint);
+  protected RunToCursorBreakpoint(@NotNull Project project, @NotNull SourcePosition pos, boolean restoreBreakpoints) {
+    super(project, null);
     myCustomPosition = pos;
     setVisible(false);
     myRestoreBreakpoints = restoreBreakpoints;
@@ -51,7 +44,51 @@ public class RunToCursorBreakpoint extends LineBreakpoint {
 
   @Override
   public SourcePosition getSourcePosition() {
-    return myCustomPosition != null ? myCustomPosition : super.getSourcePosition();
+    return myCustomPosition;
+  }
+
+  @Override
+  public void reload() {
+  }
+
+  @Override
+  public String getSuspendPolicy() {
+    return mySuspendPolicy;
+  }
+
+  public void setSuspendPolicy(String policy) {
+    mySuspendPolicy = policy;
+  }
+
+  protected boolean isLogEnabled() {
+    return false;
+  }
+
+  @Override
+  protected boolean isLogExpressionEnabled() {
+    return false;
+  }
+
+  @Override
+  public boolean isEnabled() {
+    return true;
+  }
+
+  public boolean isCountFilterEnabled() {
+    return false;
+  }
+
+  public boolean isClassFiltersEnabled() {
+    return false;
+  }
+
+  public boolean isInstanceFiltersEnabled() {
+    return false;
+  }
+
+  @Override
+  protected boolean isConditionEnabled() {
+    return false;
   }
 
   public boolean isRestoreBreakpoints() {
@@ -63,29 +100,26 @@ public class RunToCursorBreakpoint extends LineBreakpoint {
     return false;
   }
 
+  @Override
+  public boolean isValid() {
+    return true;
+  }
+
   @Override
   protected boolean isMuted(@NotNull final DebugProcessImpl debugProcess) {
     return false;  // always enabled
   }
 
   @Nullable
-  protected static RunToCursorBreakpoint create(@NotNull Project project, @NotNull Document document, int lineIndex, boolean restoreBreakpoints, XBreakpoint xBreakpoint) {
+  protected static RunToCursorBreakpoint create(@NotNull Project project, @NotNull Document document, int lineIndex, boolean restoreBreakpoints) {
     VirtualFile virtualFile = FileDocumentManager.getInstance().getFile(document);
     if (virtualFile == null) {
       return null;
     }
 
-    final RangeHighlighter highlighter = createHighlighter(project, document, lineIndex);
-    if (highlighter == null) {
-      return null;
-    }
+    PsiFile psiFile = PsiManager.getInstance(project).findFile(virtualFile);
+    SourcePosition pos = SourcePosition.createFromLine(psiFile, lineIndex);
 
-    final RunToCursorBreakpoint breakpoint = new RunToCursorBreakpoint(project, highlighter, restoreBreakpoints, xBreakpoint);
-    final RangeHighlighter h = breakpoint.getHighlighter();
-    if (h != null) {
-      h.dispose();
-    }
-
-    return (RunToCursorBreakpoint)breakpoint.init();
+    return new RunToCursorBreakpoint(project, pos, restoreBreakpoints);
   }
 }
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/StepIntoBreakpoint.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/StepIntoBreakpoint.java
index fd575177d273..af7d6755523a 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/StepIntoBreakpoint.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/StepIntoBreakpoint.java
@@ -41,7 +41,7 @@ public class StepIntoBreakpoint extends RunToCursorBreakpoint {
   private final BreakpointStepMethodFilter myFilter;
 
   StepIntoBreakpoint(@NotNull Project project, @NotNull SourcePosition pos, @NotNull BreakpointStepMethodFilter filter) {
-    super(project, pos, false, null);
+    super(project, pos, false);
     myFilter = filter;
   }
 
diff --git a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/WildcardMethodBreakpoint.java b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/WildcardMethodBreakpoint.java
index 3e3553520193..ec7f42667561 100644
--- a/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/WildcardMethodBreakpoint.java
+++ b/java/debugger/impl/src/com/intellij/debugger/ui/breakpoints/WildcardMethodBreakpoint.java
@@ -26,9 +26,7 @@ import com.intellij.debugger.engine.requests.RequestManagerImpl;
 import com.intellij.icons.AllIcons;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.InvalidDataException;
 import com.intellij.openapi.util.Key;
-import com.intellij.openapi.util.WriteExternalException;
 import com.intellij.psi.PsiClass;
 import com.intellij.psi.PsiElement;
 import com.intellij.util.StringBuilderSpinAllocator;
@@ -43,7 +41,6 @@ import com.sun.jdi.event.MethodExitEvent;
 import com.sun.jdi.request.EventRequest;
 import com.sun.jdi.request.MethodEntryRequest;
 import com.sun.jdi.request.MethodExitRequest;
-import org.jdom.Element;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.java.debugger.breakpoints.properties.JavaMethodBreakpointProperties;
@@ -126,7 +123,7 @@ public class WildcardMethodBreakpoint extends Breakpoint<JavaMethodBreakpointPro
     }
     try {
       RequestManagerImpl requestManager = debugProcess.getRequestsManager();
-      if (isWATCH_ENTRY()) {
+      if (isWatchEntry()) {
         MethodEntryRequest entryRequest = (MethodEntryRequest)findRequest(debugProcess, MethodEntryRequest.class);
         if (entryRequest == null) {
           entryRequest = requestManager.createMethodEntryRequest(this);
@@ -137,7 +134,7 @@ public class WildcardMethodBreakpoint extends Breakpoint<JavaMethodBreakpointPro
         entryRequest.addClassFilter(getClassPattern());
         debugProcess.getRequestsManager().enableRequest(entryRequest);
       }
-      if (isWATCH_EXIT()) {
+      if (isWatchExit()) {
         MethodExitRequest exitRequest = (MethodExitRequest)findRequest(debugProcess, MethodExitRequest.class);
         if (exitRequest == null) {
           exitRequest = requestManager.createMethodExitRequest(this);
@@ -252,31 +249,31 @@ public class WildcardMethodBreakpoint extends Breakpoint<JavaMethodBreakpointPro
     return new WildcardMethodBreakpoint(project, classPattern, methodName, xBreakpoint);
   }
 
-  public boolean isWATCH_ENTRY() {
+  private boolean isWatchEntry() {
     return getProperties().WATCH_ENTRY;
   }
 
-  public void setWATCH_ENTRY(boolean WATCH_ENTRY) {
+  private void setWatchEntry(boolean WATCH_ENTRY) {
     getProperties().WATCH_ENTRY = WATCH_ENTRY;
   }
 
-  public boolean isWATCH_EXIT() {
+  private boolean isWatchExit() {
     return getProperties().WATCH_EXIT;
   }
 
-  public void setWATCH_EXIT(boolean WATCH_EXIT) {
+  private void setWatchExit(boolean WATCH_EXIT) {
     getProperties().WATCH_EXIT = WATCH_EXIT;
   }
 
-  public String getClassPattern() {
+  private String getClassPattern() {
     return getProperties().myClassPattern;
   }
 
-  public void setClassPattern(String classPattern) {
+  private void setClassPattern(String classPattern) {
     getProperties().myClassPattern = classPattern;
   }
 
-  public void setMethodName(String methodName) {
+  private void setMethodName(String methodName) {
     getProperties().myMethodName = methodName;
   }
 }
diff --git a/java/debugger/impl/src/org/jetbrains/java/debugger/breakpoints/JavaBreakpointAdapterBase.java b/java/debugger/impl/src/org/jetbrains/java/debugger/breakpoints/JavaBreakpointAdapterBase.java
index 2f92c7c12428..686de9aad6eb 100644
--- a/java/debugger/impl/src/org/jetbrains/java/debugger/breakpoints/JavaBreakpointAdapterBase.java
+++ b/java/debugger/impl/src/org/jetbrains/java/debugger/breakpoints/JavaBreakpointAdapterBase.java
@@ -61,6 +61,6 @@ public abstract class JavaBreakpointAdapterBase extends XBreakpointAdapter<XLine
   }
 
   protected LineBreakpoint doCreateInstance(Project project, Document document, XLineBreakpoint<XBreakpointProperties> xBreakpoint) {
-    return LineBreakpoint.create(project, document, xBreakpoint.getLine(), xBreakpoint);
+    return LineBreakpoint.create(project, xBreakpoint);
   }
 }
diff --git a/java/debugger/impl/src/org/jetbrains/java/debugger/breakpoints/properties/JavaLineBreakpointProperties.java b/java/debugger/impl/src/org/jetbrains/java/debugger/breakpoints/properties/JavaLineBreakpointProperties.java
new file mode 100644
index 000000000000..9a892346ac04
--- /dev/null
+++ b/java/debugger/impl/src/org/jetbrains/java/debugger/breakpoints/properties/JavaLineBreakpointProperties.java
@@ -0,0 +1,22 @@
+/*
+ * Copyright 2000-2014 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 org.jetbrains.java.debugger.breakpoints.properties;
+
+/**
+ * @author egor
+ */
+public class JavaLineBreakpointProperties extends JavaBreakpointProperties<JavaLineBreakpointProperties> {
+}