platform/lang-impl/src/com/intellij/refactoring/changeSignature/CallerChooserBase.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2010 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.refactoring.changeSignature;

 import com.intellij.codeInsight.highlighting.HighlightManager;
 import com.intellij.ide.highlighter.HighlighterFactory;
 import com.intellij.openapi.application.ApplicationManager;
 import com.intellij.openapi.editor.Document;
 import com.intellij.openapi.editor.Editor;
 import com.intellij.openapi.editor.EditorFactory;
 import com.intellij.openapi.editor.colors.EditorColors;
 import com.intellij.openapi.editor.colors.EditorColorsManager;
 import com.intellij.openapi.editor.ex.EditorEx;
 import com.intellij.openapi.editor.markup.TextAttributes;
 import com.intellij.openapi.progress.ProcessCanceledException;
 import com.intellij.openapi.project.Project;
 import com.intellij.openapi.ui.DialogWrapper;
 import com.intellij.openapi.ui.Splitter;
 import com.intellij.psi.PsiDocumentManager;
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiReference;
 import com.intellij.psi.search.LocalSearchScope;
 import com.intellij.psi.search.searches.ReferencesSearch;
 import com.intellij.refactoring.RefactoringBundle;
 import com.intellij.ui.*;
 import com.intellij.ui.treeStructure.Tree;
 import com.intellij.util.Alarm;
 import com.intellij.util.Consumer;
 import com.intellij.util.Function;
 import com.intellij.util.Query;
 import com.intellij.util.containers.ContainerUtil;
 import com.intellij.util.containers.HashSet;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import javax.swing.*;
 import javax.swing.event.TreeSelectionEvent;
 import javax.swing.event.TreeSelectionListener;
 import javax.swing.tree.TreePath;
 import javax.swing.tree.TreeSelectionModel;
 import java.awt.*;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Enumeration;
 import java.util.Set;

 public abstract class CallerChooserBase<M extends PsiElement> extends DialogWrapper {
   private final M myMethod;
   private final Alarm myAlarm = new Alarm();
   private MethodNodeBase<M> myRoot;
   protected final Project myProject;
   private Tree myTree;
   private final Consumer<Set<M>> myCallback;
   private TreeSelectionListener myTreeSelectionListener;
   private Editor myCallerEditor;
   private Editor myCalleeEditor;
   private final boolean myInitDone;
   private final String myFileName;

   protected abstract MethodNodeBase<M> createTreeNode(M method, HashSet<M> called, Runnable cancelCallback);

   protected abstract M[] findDeepestSuperMethods(M method);

   public CallerChooserBase(M method, Project project, String title, Tree previousTree, String fileName, Consumer<Set<M>> callback) {
     super(true);
     myMethod = method;
     myProject = project;
     myTree = previousTree;
     myFileName = fileName;
     myCallback = callback;
     setTitle(title);
     init();
     myInitDone = true;
   }

   public Tree getTree() {
     return myTree;
   }

   @Override
   protected JComponent createCenterPanel() {
     Splitter splitter = new Splitter(false, (float)0.6);
     JPanel result = new JPanel(new BorderLayout());
     if (myTree == null) {
       myTree = createTree();
     }
     else {
       final CheckedTreeNode root = (CheckedTreeNode)myTree.getModel().getRoot();
       myRoot = (MethodNodeBase)root.getFirstChild();
     }
     myTreeSelectionListener = new TreeSelectionListener() {
       @Override
       public void valueChanged(TreeSelectionEvent e) {
         final TreePath path = e.getPath();
         if (path != null) {
           final MethodNodeBase<M> node = (MethodNodeBase)path.getLastPathComponent();
           myAlarm.cancelAllRequests();
           myAlarm.addRequest(new Runnable() {
             @Override
             public void run() {
               updateEditorTexts(node);
             }
           }, 300);
         }
       }
     };
     myTree.getSelectionModel().addTreeSelectionListener(myTreeSelectionListener);

     JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(myTree);
     splitter.setFirstComponent(scrollPane);
     final JComponent callSitesViewer = createCallSitesViewer();
     TreePath selectionPath = myTree.getSelectionPath();
     if (selectionPath == null) {
       selectionPath = new TreePath(myRoot.getPath());
       myTree.getSelectionModel().addSelectionPath(selectionPath);
     }

     final MethodNodeBase<M> node = (MethodNodeBase)selectionPath.getLastPathComponent();
     updateEditorTexts(node);

     splitter.setSecondComponent(callSitesViewer);
     result.add(splitter);
     return result;
   }

   private void updateEditorTexts(final MethodNodeBase<M> node) {
     final MethodNodeBase<M> parentNode = (MethodNodeBase)node.getParent();
     final String callerText = node != myRoot ? getText(node.getMethod()) : "";
     final Document callerDocument = myCallerEditor.getDocument();
     final String calleeText = node != myRoot ? getText(parentNode.getMethod()) : "";
     final Document calleeDocument = myCalleeEditor.getDocument();

     ApplicationManager.getApplication().runWriteAction(new Runnable() {
       @Override
       public void run() {
         callerDocument.setText(callerText);
         calleeDocument.setText(calleeText);
       }
     });

     final M caller = node.getMethod();
     final PsiElement callee = parentNode != null ? parentNode.getElementToSearch() : null;
     if (caller != null && caller.isPhysical() && callee != null) {
       HighlightManager highlighter = HighlightManager.getInstance(myProject);
       EditorColorsManager colorManager = EditorColorsManager.getInstance();
       TextAttributes attributes = colorManager.getGlobalScheme().getAttributes(EditorColors.TEXT_SEARCH_RESULT_ATTRIBUTES);
       int start = getStartOffset(caller);
       for (PsiElement element : findElementsToHighlight(caller, callee)) {
         highlighter.addRangeHighlight(myCallerEditor, element.getTextRange().getStartOffset() - start,
                                       element.getTextRange().getEndOffset() - start, attributes, false, null);
       }
     }
   }

   protected Collection<PsiElement> findElementsToHighlight(M caller, PsiElement callee) {
     Query<PsiReference> references = ReferencesSearch.search(callee, new LocalSearchScope(caller), false);
     return ContainerUtil.mapNotNull(references, new Function<PsiReference, PsiElement>() {
       @Override
       public PsiElement fun(PsiReference psiReference) {
         return psiReference.getElement();
       }
     });
   }

   @Override
   public void dispose() {
     if (myTree != null) {
       myTree.removeTreeSelectionListener(myTreeSelectionListener);
       EditorFactory.getInstance().releaseEditor(myCallerEditor);
       EditorFactory.getInstance().releaseEditor(myCalleeEditor);
     }
     super.dispose();
   }

   private String getText(final M method) {
     if (method == null) return "";
     final PsiFile file = method.getContainingFile();
     Document document = PsiDocumentManager.getInstance(myProject).getDocument(file);
     if (document != null) {
       final int start = document.getLineStartOffset(document.getLineNumber(method.getTextRange().getStartOffset()));
       final int end = document.getLineEndOffset(document.getLineNumber(method.getTextRange().getEndOffset()));
       return document.getText().substring(start, end);
     }
     return "";
   }

   private int getStartOffset(@NotNull final M method) {
     final PsiFile file = method.getContainingFile();
     Document document = PsiDocumentManager.getInstance(myProject).getDocument(file);
     return document.getLineStartOffset(document.getLineNumber(method.getTextRange().getStartOffset()));
   }

   private JComponent createCallSitesViewer() {
     Splitter splitter = new Splitter(true);
     myCallerEditor = createEditor();
     myCalleeEditor = createEditor();
     final JComponent callerComponent = myCallerEditor.getComponent();
     callerComponent.setBorder(IdeBorderFactory.createTitledBorder(RefactoringBundle.message("caller.chooser.caller.method"),
                                                                   false));
     splitter.setFirstComponent(callerComponent);
     final JComponent calleeComponent = myCalleeEditor.getComponent();
     calleeComponent.setBorder(IdeBorderFactory.createTitledBorder(RefactoringBundle.message("caller.chooser.callee.method"),
                                                                   false));
     splitter.setSecondComponent(calleeComponent);
     splitter.setBorder(IdeBorderFactory.createRoundedBorder());
     return splitter;
   }

   private Editor createEditor() {
     final EditorFactory editorFactory = EditorFactory.getInstance();
     final Document document = editorFactory.createDocument("");
     final Editor editor = editorFactory.createViewer(document, myProject);
     ((EditorEx)editor).setHighlighter(HighlighterFactory.createHighlighter(myProject, myFileName));
     return editor;
   }

   private Tree createTree() {
     final Runnable cancelCallback = new Runnable() {
       @Override
       public void run() {
         if (myInitDone) {
           close(CANCEL_EXIT_CODE);
         }
         else {
           throw new ProcessCanceledException();
         }
       }
     };
     final CheckedTreeNode root = createTreeNode(null, new HashSet<M>(), cancelCallback);
     myRoot = createTreeNode(myMethod, new HashSet<M>(), cancelCallback);
     root.add(myRoot);
     final CheckboxTree.CheckboxTreeCellRenderer cellRenderer = new CheckboxTree.CheckboxTreeCellRenderer(true, false) {
       @Override
       public void customizeRenderer(JTree tree,
                                     Object value,
                                     boolean selected,
                                     boolean expanded,
                                     boolean leaf,
                                     int row,
                                     boolean hasFocus) {
         if (value instanceof MethodNodeBase) {
           ((MethodNodeBase)value).customizeRenderer(getTextRenderer());
         }
       }
     };
     Tree tree = new CheckboxTree(cellRenderer, root, new CheckboxTreeBase.CheckPolicy(false, true, true, false));
     tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
     tree.getSelectionModel().setSelectionPath(new TreePath(myRoot.getPath()));

     return tree;
   }

   private void getSelectedMethods(Set<M> methods) {
     MethodNodeBase<M> node = myRoot;
     getSelectedMethodsInner(node, methods);
     methods.remove(node.getMethod());
   }

   private void getSelectedMethodsInner(final MethodNodeBase<M> node, final Set<M> allMethods) {
     if (node.isChecked()) {
       M method = node.getMethod();
       final M[] superMethods = findDeepestSuperMethods(method);
       if (superMethods.length == 0) {
         allMethods.add(method);
       }
       else {
         allMethods.addAll(Arrays.asList(superMethods));
       }

       final Enumeration children = node.children();
       while (children.hasMoreElements()) {
         getSelectedMethodsInner((MethodNodeBase)children.nextElement(), allMethods);
       }
     }
   }

   @Override
   protected void doOKAction() {
     final Set<M> selectedMethods = new HashSet<M>();
     getSelectedMethods(selectedMethods);
     myCallback.consume(selectedMethods);
     super.doOKAction();
   }

   @Override
   public JComponent getPreferredFocusedComponent() {
     return myTree;
   }

   @Nullable
   @Override
   protected String getDimensionServiceKey() {
     return "caller.chooser.dialog";
   }
 }
	/*
	* Copyright 2000-2010 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.refactoring.changeSignature;

	import com.intellij.codeInsight.highlighting.HighlightManager;
	import com.intellij.ide.highlighter.HighlighterFactory;
	import com.intellij.openapi.application.ApplicationManager;
	import com.intellij.openapi.editor.Document;
	import com.intellij.openapi.editor.Editor;
	import com.intellij.openapi.editor.EditorFactory;
	import com.intellij.openapi.editor.colors.EditorColors;
	import com.intellij.openapi.editor.colors.EditorColorsManager;
	import com.intellij.openapi.editor.ex.EditorEx;
	import com.intellij.openapi.editor.markup.TextAttributes;
	import com.intellij.openapi.progress.ProcessCanceledException;
	import com.intellij.openapi.project.Project;
	import com.intellij.openapi.ui.DialogWrapper;
	import com.intellij.openapi.ui.Splitter;
	import com.intellij.psi.PsiDocumentManager;
	import com.intellij.psi.PsiElement;
	import com.intellij.psi.PsiFile;
	import com.intellij.psi.PsiReference;
	import com.intellij.psi.search.LocalSearchScope;
	import com.intellij.psi.search.searches.ReferencesSearch;
	import com.intellij.refactoring.RefactoringBundle;
	import com.intellij.ui.*;
	import com.intellij.ui.treeStructure.Tree;
	import com.intellij.util.Alarm;
	import com.intellij.util.Consumer;
	import com.intellij.util.Function;
	import com.intellij.util.Query;
	import com.intellij.util.containers.ContainerUtil;
	import com.intellij.util.containers.HashSet;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;

	import javax.swing.*;
	import javax.swing.event.TreeSelectionEvent;
	import javax.swing.event.TreeSelectionListener;
	import javax.swing.tree.TreePath;
	import javax.swing.tree.TreeSelectionModel;
	import java.awt.*;
	import java.util.Arrays;
	import java.util.Collection;
	import java.util.Enumeration;
	import java.util.Set;

	public abstract class CallerChooserBase<M extends PsiElement> extends DialogWrapper {
	private final M myMethod;
	private final Alarm myAlarm = new Alarm();
	private MethodNodeBase<M> myRoot;
	protected final Project myProject;
	private Tree myTree;
	private final Consumer<Set<M>> myCallback;
	private TreeSelectionListener myTreeSelectionListener;
	private Editor myCallerEditor;
	private Editor myCalleeEditor;
	private final boolean myInitDone;
	private final String myFileName;

	protected abstract MethodNodeBase<M> createTreeNode(M method, HashSet<M> called, Runnable cancelCallback);

	protected abstract M[] findDeepestSuperMethods(M method);

	public CallerChooserBase(M method, Project project, String title, Tree previousTree, String fileName, Consumer<Set<M>> callback) {
	super(true);
	myMethod = method;
	myProject = project;
	myTree = previousTree;
	myFileName = fileName;
	myCallback = callback;
	setTitle(title);
	init();
	myInitDone = true;
	}

	public Tree getTree() {
	return myTree;
	}

	@Override
	protected JComponent createCenterPanel() {
	Splitter splitter = new Splitter(false, (float)0.6);
	JPanel result = new JPanel(new BorderLayout());
	if (myTree == null) {
	myTree = createTree();
	}
	else {
	final CheckedTreeNode root = (CheckedTreeNode)myTree.getModel().getRoot();
	myRoot = (MethodNodeBase)root.getFirstChild();
	}
	myTreeSelectionListener = new TreeSelectionListener() {
	@Override
	public void valueChanged(TreeSelectionEvent e) {
	final TreePath path = e.getPath();
	if (path != null) {
	final MethodNodeBase<M> node = (MethodNodeBase)path.getLastPathComponent();
	myAlarm.cancelAllRequests();
	myAlarm.addRequest(new Runnable() {
	@Override
	public void run() {
	updateEditorTexts(node);
	}
	}, 300);
	}
	}
	};
	myTree.getSelectionModel().addTreeSelectionListener(myTreeSelectionListener);

	JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(myTree);
	splitter.setFirstComponent(scrollPane);
	final JComponent callSitesViewer = createCallSitesViewer();
	TreePath selectionPath = myTree.getSelectionPath();
	if (selectionPath == null) {
	selectionPath = new TreePath(myRoot.getPath());
	myTree.getSelectionModel().addSelectionPath(selectionPath);
	}

	final MethodNodeBase<M> node = (MethodNodeBase)selectionPath.getLastPathComponent();
	updateEditorTexts(node);

	splitter.setSecondComponent(callSitesViewer);
	result.add(splitter);
	return result;
	}

	private void updateEditorTexts(final MethodNodeBase<M> node) {
	final MethodNodeBase<M> parentNode = (MethodNodeBase)node.getParent();
	final String callerText = node != myRoot ? getText(node.getMethod()) : "";
	final Document callerDocument = myCallerEditor.getDocument();
	final String calleeText = node != myRoot ? getText(parentNode.getMethod()) : "";
	final Document calleeDocument = myCalleeEditor.getDocument();

	ApplicationManager.getApplication().runWriteAction(new Runnable() {
	@Override
	public void run() {
	callerDocument.setText(callerText);
	calleeDocument.setText(calleeText);
	}
	});

	final M caller = node.getMethod();
	final PsiElement callee = parentNode != null ? parentNode.getElementToSearch() : null;
	if (caller != null && caller.isPhysical() && callee != null) {
	HighlightManager highlighter = HighlightManager.getInstance(myProject);
	EditorColorsManager colorManager = EditorColorsManager.getInstance();
	TextAttributes attributes = colorManager.getGlobalScheme().getAttributes(EditorColors.TEXT_SEARCH_RESULT_ATTRIBUTES);
	int start = getStartOffset(caller);
	for (PsiElement element : findElementsToHighlight(caller, callee)) {
	highlighter.addRangeHighlight(myCallerEditor, element.getTextRange().getStartOffset() - start,
	element.getTextRange().getEndOffset() - start, attributes, false, null);
	}
	}
	}

	protected Collection<PsiElement> findElementsToHighlight(M caller, PsiElement callee) {
	Query<PsiReference> references = ReferencesSearch.search(callee, new LocalSearchScope(caller), false);
	return ContainerUtil.mapNotNull(references, new Function<PsiReference, PsiElement>() {
	@Override
	public PsiElement fun(PsiReference psiReference) {
	return psiReference.getElement();
	}
	});
	}

	@Override
	public void dispose() {
	if (myTree != null) {
	myTree.removeTreeSelectionListener(myTreeSelectionListener);
	EditorFactory.getInstance().releaseEditor(myCallerEditor);
	EditorFactory.getInstance().releaseEditor(myCalleeEditor);
	}
	super.dispose();
	}

	private String getText(final M method) {
	if (method == null) return "";
	final PsiFile file = method.getContainingFile();
	Document document = PsiDocumentManager.getInstance(myProject).getDocument(file);
	if (document != null) {
	final int start = document.getLineStartOffset(document.getLineNumber(method.getTextRange().getStartOffset()));
	final int end = document.getLineEndOffset(document.getLineNumber(method.getTextRange().getEndOffset()));
	return document.getText().substring(start, end);
	}
	return "";
	}

	private int getStartOffset(@NotNull final M method) {
	final PsiFile file = method.getContainingFile();
	Document document = PsiDocumentManager.getInstance(myProject).getDocument(file);
	return document.getLineStartOffset(document.getLineNumber(method.getTextRange().getStartOffset()));
	}

	private JComponent createCallSitesViewer() {
	Splitter splitter = new Splitter(true);
	myCallerEditor = createEditor();
	myCalleeEditor = createEditor();
	final JComponent callerComponent = myCallerEditor.getComponent();
	callerComponent.setBorder(IdeBorderFactory.createTitledBorder(RefactoringBundle.message("caller.chooser.caller.method"),
	false));
	splitter.setFirstComponent(callerComponent);
	final JComponent calleeComponent = myCalleeEditor.getComponent();
	calleeComponent.setBorder(IdeBorderFactory.createTitledBorder(RefactoringBundle.message("caller.chooser.callee.method"),
	false));
	splitter.setSecondComponent(calleeComponent);
	splitter.setBorder(IdeBorderFactory.createRoundedBorder());
	return splitter;
	}

	private Editor createEditor() {
	final EditorFactory editorFactory = EditorFactory.getInstance();
	final Document document = editorFactory.createDocument("");
	final Editor editor = editorFactory.createViewer(document, myProject);
	((EditorEx)editor).setHighlighter(HighlighterFactory.createHighlighter(myProject, myFileName));
	return editor;
	}

	private Tree createTree() {
	final Runnable cancelCallback = new Runnable() {
	@Override
	public void run() {
	if (myInitDone) {
	close(CANCEL_EXIT_CODE);
	}
	else {
	throw new ProcessCanceledException();
	}
	}
	};
	final CheckedTreeNode root = createTreeNode(null, new HashSet<M>(), cancelCallback);
	myRoot = createTreeNode(myMethod, new HashSet<M>(), cancelCallback);
	root.add(myRoot);
	final CheckboxTree.CheckboxTreeCellRenderer cellRenderer = new CheckboxTree.CheckboxTreeCellRenderer(true, false) {
	@Override
	public void customizeRenderer(JTree tree,
	Object value,
	boolean selected,
	boolean expanded,
	boolean leaf,
	int row,
	boolean hasFocus) {
	if (value instanceof MethodNodeBase) {
	((MethodNodeBase)value).customizeRenderer(getTextRenderer());
	}
	}
	};
	Tree tree = new CheckboxTree(cellRenderer, root, new CheckboxTreeBase.CheckPolicy(false, true, true, false));
	tree.getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION);
	tree.getSelectionModel().setSelectionPath(new TreePath(myRoot.getPath()));

	return tree;
	}

	private void getSelectedMethods(Set<M> methods) {
	MethodNodeBase<M> node = myRoot;
	getSelectedMethodsInner(node, methods);
	methods.remove(node.getMethod());
	}

	private void getSelectedMethodsInner(final MethodNodeBase<M> node, final Set<M> allMethods) {
	if (node.isChecked()) {
	M method = node.getMethod();
	final M[] superMethods = findDeepestSuperMethods(method);
	if (superMethods.length == 0) {
	allMethods.add(method);
	}
	else {
	allMethods.addAll(Arrays.asList(superMethods));
	}

	final Enumeration children = node.children();
	while (children.hasMoreElements()) {
	getSelectedMethodsInner((MethodNodeBase)children.nextElement(), allMethods);
	}
	}
	}

	@Override
	protected void doOKAction() {
	final Set<M> selectedMethods = new HashSet<M>();
	getSelectedMethods(selectedMethods);
	myCallback.consume(selectedMethods);
	super.doOKAction();
	}

	@Override
	public JComponent getPreferredFocusedComponent() {
	return myTree;
	}

	@Nullable
	@Override
	protected String getDimensionServiceKey() {
	return "caller.chooser.dialog";
	}
	}