plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/ui/MethodOrClosureScopeChooser.java

   1 /*
   2  * Copyright 2000-2014 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.jetbrains.plugins.groovy.refactoring.ui;
  17
  18 import com.intellij.openapi.application.ModalityState;
  19 import com.intellij.openapi.diagnostic.Logger;
  20 import com.intellij.openapi.editor.Editor;
  21 import com.intellij.openapi.editor.colors.EditorColors;
  22 import com.intellij.openapi.editor.colors.EditorColorsManager;
  23 import com.intellij.openapi.editor.markup.*;
  24 import com.intellij.openapi.ui.popup.JBPopup;
  25 import com.intellij.openapi.ui.popup.JBPopupAdapter;
  26 import com.intellij.openapi.ui.popup.JBPopupFactory;
  27 import com.intellij.openapi.ui.popup.LightweightWindowEvent;
  28 import com.intellij.openapi.util.Iconable;
  29 import com.intellij.openapi.util.Pair;
  30 import com.intellij.openapi.util.TextRange;
  31 import com.intellij.openapi.wm.IdeFocusManager;
  32 import com.intellij.psi.PsiElement;
  33 import com.intellij.psi.PsiMethod;
  34 import com.intellij.psi.PsiSubstitutor;
  35 import com.intellij.psi.util.PsiFormatUtil;
  36 import com.intellij.psi.util.PsiFormatUtilBase;
  37 import com.intellij.ui.ScrollPaneFactory;
  38 import com.intellij.ui.components.JBList;
  39 import com.intellij.util.PairFunction;
  40 import icons.JetgroovyIcons;
  41 import org.jetbrains.annotations.NonNls;
  42 import org.jetbrains.annotations.NotNull;
  43 import org.jetbrains.annotations.Nullable;
  44 import org.jetbrains.plugins.groovy.lang.lexer.GroovyTokenTypes;
  45 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrParametersOwner;
  46 import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrVariable;
  47 import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrClosableBlock;
  48 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrAssignmentExpression;
  49 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
  50 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
  51 import org.jetbrains.plugins.groovy.lang.psi.api.statements.typedef.members.GrMethod;
  52
  53 import javax.swing.*;
  54 import javax.swing.event.ListSelectionEvent;
  55 import javax.swing.event.ListSelectionListener;
  56 import java.awt.*;
  57 import java.awt.event.ActionEvent;
  58 import java.awt.event.ActionListener;
  59 import java.awt.event.KeyEvent;
  60 import java.util.ArrayList;
  61 import java.util.Collections;
  62 import java.util.List;
  63
  64 /**
  65  * @author Max Medvedev
  66  */
  67 public class MethodOrClosureScopeChooser {
  68   private static final Logger LOG = Logger.getInstance(MethodOrClosureScopeChooser.class);
  69
  70   @NonNls private static final String USE_SUPER_METHOD_OF = "Change base method";
  71   @NonNls private static final String CHANGE_USAGES_OF = "Change usages";
  72
  73   public interface JBPopupOwner {
  74     JBPopup get();
  75   }
  76
  77   /**
  78    * @param callback is invoked if any scope was chosen. The first arg is this scope and the second arg is a psielement to search for (super method of chosen method or
  79    *                 variable if the scope is a closure)
  80    */
  81   public static JBPopup create(List<? extends GrParametersOwner> scopes,
  82                                final Editor editor,
  83                                final JBPopupOwner popupRef,
  84                                final PairFunction<GrParametersOwner, PsiElement, Object> callback) {
  85     final JPanel panel = new JPanel(new BorderLayout());
  86     final JCheckBox superMethod = new JCheckBox(USE_SUPER_METHOD_OF, true);
  87     superMethod.setMnemonic('U');
  88     panel.add(superMethod, BorderLayout.SOUTH);
  89     final JBList list = new JBList(scopes.toArray());
  90     list.setVisibleRowCount(5);
  91     list.setCellRenderer(new DefaultListCellRenderer() {
  92       @Override
  93       public Component getListCellRendererComponent(JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {
  94         super.getListCellRendererComponent(list, value, index, isSelected, cellHasFocus);
  95
  96         final String text;
  97         if (value instanceof PsiMethod) {
  98           final PsiMethod method = (PsiMethod)value;
  99           text = PsiFormatUtil.formatMethod(method, PsiSubstitutor.EMPTY,
 100                                             PsiFormatUtilBase.SHOW_CONTAINING_CLASS |
 101                                             PsiFormatUtilBase.SHOW_NAME |
 102                                             PsiFormatUtilBase.SHOW_PARAMETERS,
 103                                             PsiFormatUtilBase.SHOW_TYPE);
 104           final int flags = Iconable.ICON_FLAG_VISIBILITY;
 105           final Icon icon = method.getIcon(flags);
 106           if (icon != null) setIcon(icon);
 107         }
 108         else {
 109           LOG.assertTrue(value instanceof GrClosableBlock);
 110           setIcon(JetgroovyIcons.Groovy.Groovy_16x16);
 111           text = "{...}";
 112         }
 113         setText(text);
 114         return this;
 115       }
 116     });
 117     list.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 118     list.setSelectedIndex(0);
 119     final List<RangeHighlighter> highlighters = new ArrayList<>();
 120     final TextAttributes attributes =
 121       EditorColorsManager.getInstance().getGlobalScheme().getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES);
 122     list.addListSelectionListener(new ListSelectionListener() {
 123       @Override
 124       public void valueChanged(final ListSelectionEvent e) {
 125         final GrParametersOwner selectedMethod = (GrParametersOwner)list.getSelectedValue();
 126         if (selectedMethod == null) return;
 127         dropHighlighters(highlighters);
 128         updateView(selectedMethod, editor, attributes, highlighters, superMethod);
 129       }
 130     });
 131     updateView(scopes.get(0), editor, attributes, highlighters, superMethod);
 132     final JScrollPane scrollPane = ScrollPaneFactory.createScrollPane(list);
 133     scrollPane.setBorder(null);
 134     panel.add(scrollPane, BorderLayout.CENTER);
 135
 136     final List<Pair<ActionListener, KeyStroke>> keyboardActions = Collections.singletonList(
 137       Pair.<ActionListener, KeyStroke>create(new ActionListener() {
 138         @Override
 139         public void actionPerformed(ActionEvent e) {
 140           final GrParametersOwner ToSearchIn = (GrParametersOwner)list.getSelectedValue();
 141           final JBPopup popup = popupRef.get();
 142           if (popup != null && popup.isVisible()) {
 143             popup.cancel();
 144           }
 145
 146
 147           final PsiElement toSearchFor;
 148           if (ToSearchIn instanceof GrMethod) {
 149             final GrMethod method = (GrMethod)ToSearchIn;
 150             toSearchFor = superMethod.isEnabled() && superMethod.isSelected() ? method.findDeepestSuperMethod() : method;
 151           }
 152           else {
 153             toSearchFor = superMethod.isEnabled() && superMethod.isSelected() ? ToSearchIn.getParent() : null;
 154           }
 155           IdeFocusManager.findInstance().doWhenFocusSettlesDown(() -> callback.fun(ToSearchIn, toSearchFor), ModalityState.current());
 156         }
 157       }, KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0)));
 158
 159
 160     return JBPopupFactory.getInstance().createComponentPopupBuilder(panel, list)
 161       .setTitle("Introduce parameter to")
 162       .setMovable(false)
 163       .setResizable(false)
 164       .setRequestFocus(true)
 165       .setKeyboardActions(keyboardActions).addListener(new JBPopupAdapter() {
 166         @Override
 167         public void onClosed(LightweightWindowEvent event) {
 168           dropHighlighters(highlighters);
 169         }
 170       }).createPopup();
 171   }
 172
 173
 174   public static void updateView(GrParametersOwner selectedMethod,
 175                                 Editor editor,
 176                                 TextAttributes attributes,
 177                                 List<RangeHighlighter> highlighters,
 178                                 JCheckBox superMethod) {
 179     final MarkupModel markupModel = editor.getMarkupModel();
 180     final TextRange textRange = selectedMethod.getTextRange();
 181     final RangeHighlighter rangeHighlighter =
 182       markupModel.addRangeHighlighter(textRange.getStartOffset(), textRange.getEndOffset(), HighlighterLayer.SELECTION - 1, attributes,
 183                                       HighlighterTargetArea.EXACT_RANGE);
 184     highlighters.add(rangeHighlighter);
 185     if (selectedMethod instanceof GrMethod) {
 186       superMethod.setText(USE_SUPER_METHOD_OF);
 187       superMethod.setEnabled(((GrMethod)selectedMethod).findDeepestSuperMethod() != null);
 188     }
 189     else {
 190       superMethod.setText(CHANGE_USAGES_OF);
 191       superMethod.setEnabled(findVariableToUse(selectedMethod) != null);
 192     }
 193   }
 194
 195   @Nullable
 196   public static GrVariable findVariableToUse(@NotNull GrParametersOwner owner) {
 197     final PsiElement parent = owner.getParent();
 198     if (parent instanceof GrVariable) return (GrVariable)parent;
 199     if (parent instanceof GrAssignmentExpression &&
 200         ((GrAssignmentExpression)parent).getRValue() == owner &&
 201         ((GrAssignmentExpression)parent).getOperationTokenType() == GroovyTokenTypes.mASSIGN) {
 202       final GrExpression lValue = ((GrAssignmentExpression)parent).getLValue();
 203       if (lValue instanceof GrReferenceExpression) {
 204         final PsiElement resolved = ((GrReferenceExpression)lValue).resolve();
 205         if (resolved instanceof GrVariable) {
 206           return (GrVariable)resolved;
 207         }
 208       }
 209     }
 210     return null;
 211   }
 212
 213   private static void dropHighlighters(List<RangeHighlighter> highlighters) {
 214     for (RangeHighlighter highlighter : highlighters) {
 215       highlighter.dispose();
 216     }
 217     highlighters.clear();
 218   }
 219 }