EvaluationProvider.java

package jetbrains.mps.debugger.java.runtime.evaluation;

/*Generated by MPS */

import jetbrains.mps.debug.api.evaluation.IEvaluationProvider;
import jetbrains.mps.debugger.java.runtime.state.DebugSession;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.mps.openapi.module.SModuleReference;
import java.util.List;
import jetbrains.mps.debugger.java.runtime.evaluation.container.IEvaluationContainer;
import java.util.ArrayList;
import org.jetbrains.annotations.NotNull;
import jetbrains.mps.debug.api.DebugSessionManagerComponent;
import jetbrains.mps.debug.api.AbstractDebugSession;
import org.jetbrains.mps.openapi.module.SRepository;
import jetbrains.mps.debugger.java.runtime.evaluation.container.EvaluationModule;
import jetbrains.mps.extapi.module.SRepositoryExt;
import org.jetbrains.mps.openapi.module.SModule;
import jetbrains.mps.project.Project;
import jetbrains.mps.internal.collections.runtime.ListSequence;
import org.jetbrains.mps.openapi.model.SNodeReference;
import jetbrains.mps.debugger.java.api.state.JavaUiState;
import jetbrains.mps.baseLanguage.closures.runtime._FunctionTypes;
import jetbrains.mps.debugger.java.runtime.evaluation.container.Properties;
import com.intellij.openapi.application.ApplicationManager;
import jetbrains.mps.debugger.java.runtime.ui.evaluation.EvaluationDialog;
import jetbrains.mps.ide.project.ProjectHelper;
import jetbrains.mps.debugger.java.runtime.ui.evaluation.EditWatchDialog;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import javax.swing.JComponent;
import jetbrains.mps.debugger.java.runtime.ui.evaluation.WatchesPanel;
import jetbrains.mps.debugger.java.runtime.evaluation.model.EvaluationWithContextContainer;

public class EvaluationProvider implements IEvaluationProvider {
  private final DebugSession myDebugSession;
  @Nullable
  private SModuleReference myContainerModuleRef;
  private final List<IEvaluationContainer> myWatches = new ArrayList<IEvaluationContainer>();
  private final List<EvaluationProvider.IWatchListener> myWatchListeners = new ArrayList<EvaluationProvider.IWatchListener>();

  public EvaluationProvider(@NotNull DebugSession debugSession) {
    myDebugSession = debugSession;
    DebugSessionManagerComponent.getInstance(myDebugSession.getIdeaProject()).addDebugSessionListener(new DebugSessionManagerComponent.DebugSessionAdapter() {
      @Override
      public void registered(AbstractDebugSession session) {
        if (myDebugSession.equals(session)) {
          init();
        }
      }
      @Override
      public void detached(AbstractDebugSession session) {
        if (myDebugSession.equals(session)) {
          dispose();
          DebugSessionManagerComponent.getInstance(myDebugSession.getIdeaProject()).removeDebugSessionListener(this);
        }
      }
    });
  }

  private synchronized void init() {
    final SRepository repository = myDebugSession.getProject().getRepository();
    repository.getModelAccess().runWriteAction(new Runnable() {
      public void run() {
        EvaluationModule module = new EvaluationModule();
        ((SRepositoryExt) repository).registerModule(module, myDebugSession.getProject());
        myContainerModuleRef = module.getModuleReference();
      }
    });
  }

  private synchronized void dispose() {
    final SRepository repository = myDebugSession.getProject().getRepository();
    assert myContainerModuleRef != null;
    repository.getModelAccess().runWriteAction(new Runnable() {
      public void run() {
        SModule resolved = myContainerModuleRef.resolve(repository);
        if (resolved != null) {
          ((SRepositoryExt) repository).unregisterModule(resolved, myDebugSession.getProject());
        }
        myContainerModuleRef = null;
      }
    });
  }

  @Override
  public boolean canEvaluate() {
    return myDebugSession.isStepEnabled();
  }

  @Override
  public void showEvaluationDialog(Project mpsProject) {
    showEvaluationDialog(mpsProject, ListSequence.fromList(new ArrayList<SNodeReference>()));
  }

  @Override
  public void showEvaluationDialog(final Project mpsProject, final List<SNodeReference> selectedNodes) {
    final JavaUiState state = myDebugSession.getUiState();
    myDebugSession.getEventsProcessor().scheduleEvaluation(new _FunctionTypes._void_P0_E0() {
      public void invoke() {
        if (state.isPausedOnBreakpoint()) {
          createEvaluationContainer(Properties.IS_DEVELOPER_MODE, selectedNodes, new _FunctionTypes._void_P1_E0<IEvaluationContainer>() {
            public void invoke(IEvaluationContainer container) {
              ApplicationManager.getApplication().assertIsDispatchThread();
              EvaluationDialog evaluationDialog = new EvaluationDialog(ProjectHelper.toIdeaProject(mpsProject), EvaluationProvider.this, container);
              evaluationDialog.show();
            }
          });
        }
      }
    }, state.getThread().getThread());
  }

  public void showEditWatchDialog(@NotNull com.intellij.openapi.project.Project ideaProject, final IEvaluationContainer model) {
    ApplicationManager.getApplication().assertIsDispatchThread();
    final EditWatchDialog editWatchDialog = new EditWatchDialog(ideaProject, this, model);
    editWatchDialog.getWindow().addWindowListener(new WindowAdapter() {
      @Override
      public void windowClosed(WindowEvent e) {
        fireWatchUpdated(model);
      }
    });
    editWatchDialog.show();
  }

  @Override
  public JComponent createWatchesPanel() {
    return new WatchesPanel(this);
  }

  public void addWatch(final IEvaluationContainer evaluationModel) {
    myDebugSession.getEventsProcessor().schedule(new _FunctionTypes._void_P0_E0() {
      public void invoke() {
        evaluationModel.copy(true, new _FunctionTypes._void_P1_E0<IEvaluationContainer>() {
          public void invoke(IEvaluationContainer container) {
            synchronized (myWatches) {
              myWatches.add(container);
            }
            fireWatchAdded(container);
          }
        });
      }
    });
  }

  public void createWatch() {
    myDebugSession.getEventsProcessor().schedule(new _FunctionTypes._void_P0_E0() {
      public void invoke() {

        createEvaluationContainer(true, new _FunctionTypes._void_P1_E0<IEvaluationContainer>() {
          public void invoke(final IEvaluationContainer container) {
            ApplicationManager.getApplication().assertIsDispatchThread();
            EditWatchDialog editWatchDialog = new EditWatchDialog(myDebugSession.getIdeaProject(), EvaluationProvider.this, container, new _FunctionTypes._void_P0_E0() {
              public void invoke() {
                addWatch(container);
              }
            });
            editWatchDialog.show();
          }
        });
      }
    });
  }

  public void removeWatch(IEvaluationContainer model) {
    synchronized (myWatches) {
      myWatches.remove(model);
    }
    fireWatchRemoved(model);
  }

  public DebugSession getDebugSession() {
    return myDebugSession;
  }

  @Nullable
  private synchronized IEvaluationContainer createEvaluationContainer(boolean isWatch, _FunctionTypes._void_P1_E0<? super IEvaluationContainer> onNodeSetUp) {
    if (myContainerModuleRef == null) {
      return null;
    }
    return new EvaluationWithContextContainer(myDebugSession.getProject(), myDebugSession, myContainerModuleRef, ListSequence.fromList(new ArrayList<SNodeReference>()), isWatch, onNodeSetUp);
  }

  @Nullable
  private synchronized IEvaluationContainer createEvaluationContainer(boolean isWatch, List<SNodeReference> selectedNodes, _FunctionTypes._void_P1_E0<? super IEvaluationContainer> onNodeSetUp) {
    if (myContainerModuleRef == null) {
      return null;
    }
    return new EvaluationWithContextContainer(myDebugSession.getProject(), myDebugSession, myContainerModuleRef, selectedNodes, isWatch, onNodeSetUp);
  }

  public List<IEvaluationContainer> getWatches() {
    List<IEvaluationContainer> watchesCopy = new ArrayList<IEvaluationContainer>();
    synchronized (myWatches) {
      watchesCopy.addAll(myWatches);
    }
    return watchesCopy;
  }

  private List<EvaluationProvider.IWatchListener> getListeners() {
    List<EvaluationProvider.IWatchListener> listeners = new ArrayList<EvaluationProvider.IWatchListener>();
    synchronized (myWatchListeners) {
      listeners.addAll(myWatchListeners);
    }
    return listeners;
  }

  private void fireWatchAdded(IEvaluationContainer model) {
    for (EvaluationProvider.IWatchListener listener : getListeners()) {
      listener.watchAdded(model);
    }
  }

  private void fireWatchUpdated(IEvaluationContainer model) {
    for (EvaluationProvider.IWatchListener listener : getListeners()) {
      listener.watchUpdated(model);
    }
  }

  private void fireWatchRemoved(IEvaluationContainer model) {
    for (EvaluationProvider.IWatchListener listener : getListeners()) {
      listener.watchRemoved(model);
    }
  }

  public void addWatchListener(@NotNull EvaluationProvider.IWatchListener listener) {
    synchronized (myWatchListeners) {
      myWatchListeners.add(listener);
    }
  }

  public void removeWatchListener(@NotNull EvaluationProvider.IWatchListener listener) {
    synchronized (myWatchListeners) {
      myWatchListeners.remove(listener);
    }
  }
  public interface IWatchListener {
    void watchAdded(IEvaluationContainer model);
    void watchUpdated(IEvaluationContainer model);
    void watchRemoved(IEvaluationContainer model);
  }
  public static class WatchAdapter implements EvaluationProvider.IWatchListener {
    public WatchAdapter() {
    }
    @Override
    public void watchAdded(IEvaluationContainer model) {
    }
    @Override
    public void watchUpdated(IEvaluationContainer model) {
    }
    @Override
    public void watchRemoved(IEvaluationContainer model) {
    }
  }
}