DefaultRefactoringUI.java

package jetbrains.mps.ide.platform.actions.core;

/*Generated by MPS */

import jetbrains.mps.refactoring.participant.RefactoringUI;
import org.apache.log4j.Logger;
import org.apache.log4j.LogManager;
import com.intellij.openapi.project.Project;
import org.jetbrains.mps.openapi.module.SRepository;
import jetbrains.mps.project.MPSProject;
import java.util.List;
import jetbrains.mps.refactoring.participant.RefactoringParticipant;
import jetbrains.mps.internal.collections.runtime.ListSequence;
import jetbrains.mps.internal.collections.runtime.ISelector;
import jetbrains.mps.baseLanguage.closures.runtime._FunctionTypes;
import org.jetbrains.mps.openapi.util.ProgressMonitor;
import com.intellij.openapi.progress.ProgressManager;
import com.intellij.openapi.progress.Task;
import org.jetbrains.annotations.NotNull;
import com.intellij.openapi.progress.ProgressIndicator;
import jetbrains.mps.progress.ProgressMonitorAdapter;
import jetbrains.mps.ide.findusages.model.SearchResults;
import jetbrains.mps.ide.findusages.model.SearchTask;
import jetbrains.mps.refactoring.participant.RefactoringSession;
import jetbrains.mps.ide.platform.refactoring.UsagesModelTracker;
import jetbrains.mps.ide.platform.refactoring.RefactoringAccessEx;
import jetbrains.mps.ide.platform.refactoring.RefactoringViewAction;
import jetbrains.mps.ide.platform.refactoring.RefactoringViewItem;
import com.intellij.openapi.ui.Messages;
import org.apache.log4j.Level;
import org.jetbrains.mps.openapi.module.ModelAccess;

public class DefaultRefactoringUI implements RefactoringUI {
  private static final Logger LOG = LogManager.getLogger(DefaultRefactoringUI.class);
  protected Project myProject;
  protected SRepository myRepository;
  public DefaultRefactoringUI(Project project, SRepository repository) {
    myRepository = repository;
    myProject = project;
  }
  public DefaultRefactoringUI(MPSProject mpsProject) {
    this(mpsProject.getProject(), mpsProject.getRepository());
  }
  public void prepare(Runnable task) {
    myRepository.getModelAccess().runReadAction(task);
  }
  public List<RefactoringParticipant.Option> selectParticipants(final List<RefactoringParticipant.Option> options) {
    if (ListSequence.fromList(options).isEmpty()) {
      return options;
    }
    List<Integer> selectedOptionIndices = SelectOptionsDialog.selectOptions(myProject, ListSequence.fromList(options).select(new ISelector<RefactoringParticipant.Option, String>() {
      public String select(RefactoringParticipant.Option it) {
        return it.getDescription();
      }
    }).toListSequence(), "Select Participants", "Select how to update usages:");
    if (selectedOptionIndices == null) {
      return null;
    }
    return ListSequence.fromList(selectedOptionIndices).select(new ISelector<Integer, RefactoringParticipant.Option>() {
      public RefactoringParticipant.Option select(Integer i) {
        return ListSequence.fromList(options).getElement(i);
      }
    }).toListSequence();
  }
  public void runSearch(final _FunctionTypes._void_P1_E0<? super ProgressMonitor> task) {
    ProgressManager.getInstance().run(new Task.Modal(myProject, "Refactoring", true) {
      public void run(@NotNull final ProgressIndicator progressIndicator) {
        progressIndicator.setIndeterminate(false);
        DefaultRefactoringUI.this.myRepository.getModelAccess().runReadAction(new Runnable() {
          public void run() {
            ProgressMonitorAdapter progressMonitor = new ProgressMonitorAdapter(progressIndicator);
            task.invoke(progressMonitor);
          }
        });
      }
    });
  }

  public void showRefactoringView(final Runnable performRefactoringTask, String refactoringName, SearchResults searchResults, final SearchTask rerunTask, RefactoringSession refactoringSession) {
    final UsagesModelTracker usagesModelTracker = new UsagesModelTracker(myRepository);
    RefactoringAccessEx.getInstance().showRefactoringView(myProject, new RefactoringViewAction() {
      public void performAction(final RefactoringViewItem refactoringViewItem) {
        myRepository.getModelAccess().executeCommand(new Runnable() {
          public void run() {
            if (usagesModelTracker.isChanged()) {
              Messages.showMessageDialog(myProject, "Cannot perform refactoring operation.\nThere were changes in code after usages have been found.\nPlease perform usage search again.", "Changes Detected", Messages.getErrorIcon());
            } else {
              try {
                performRefactoringTask.run();
              } catch (RuntimeException exception) {
                if (LOG.isEnabledFor(Level.ERROR)) {
                  LOG.error("Exception during refactoring: ", exception);
                }
              }
              refactoringViewItem.close();
            }
          }
        });
      }
    }, new Runnable() {
      public void run() {
        usagesModelTracker.dispose();
      }
    }, searchResults, new SearchTask() {
      public boolean canExecute() {
        return rerunTask.canExecute();
      }
      public SearchResults execute(ModelAccess modelAccess, ProgressMonitor progressMonitor) {
        usagesModelTracker.reset();
        return rerunTask.execute(modelAccess, progressMonitor);
      }
    }, refactoringName);
  }
}