java/java-impl/src/com/intellij/refactoring/anonymousToInner/AnonymousToInnerDialog.java

   1
   2 /*
   3  * Copyright 2000-2009 JetBrains s.r.o.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  * http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17 package com.intellij.refactoring.anonymousToInner;
  18
  19 import com.intellij.openapi.diagnostic.Logger;
  20 import com.intellij.openapi.help.HelpManager;
  21 import com.intellij.openapi.project.Project;
  22 import com.intellij.openapi.ui.DialogWrapper;
  23 import com.intellij.psi.*;
  24 import com.intellij.psi.codeStyle.JavaCodeStyleManager;
  25 import com.intellij.psi.codeStyle.VariableKind;
  26 import com.intellij.refactoring.HelpID;
  27 import com.intellij.refactoring.RefactoringBundle;
  28 import com.intellij.refactoring.util.CommonRefactoringUtil;
  29 import com.intellij.refactoring.util.ParameterTablePanel;
  30 import com.intellij.refactoring.util.RefactoringMessageUtil;
  31 import com.intellij.ui.EditorTextField;
  32 import com.intellij.ui.IdeBorderFactory;
  33 import com.intellij.ui.NonFocusableCheckBox;
  34 import com.intellij.util.containers.HashMap;
  35 import org.jetbrains.annotations.NonNls;
  36
  37 import javax.swing.*;
  38 import java.awt.*;
  39 import java.util.Map;
  40
  41 class AnonymousToInnerDialog extends DialogWrapper{
  42   private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.anonymousToInner.AnonymousToInnerDialog");
  43
  44   private final Project myProject;
  45   private final PsiAnonymousClass myAnonClass;
  46   private final boolean myNeedsThis;
  47
  48   private EditorTextField myNameField;
  49   private final ParameterTablePanel.VariableData[] myVariableData;
  50   private final Map<PsiVariable,VariableInfo> myVariableToInfoMap = new HashMap<PsiVariable, VariableInfo>();
  51   private JCheckBox myCbMakeStatic;
  52
  53   public AnonymousToInnerDialog(Project project, PsiAnonymousClass anonClass, final VariableInfo[] variableInfos,
  54                                 boolean needsThis) {
  55     super(project, true);
  56     myProject = project;
  57     myAnonClass = anonClass;
  58     myNeedsThis = needsThis;
  59
  60     setTitle(AnonymousToInnerHandler.REFACTORING_NAME);
  61
  62     for (VariableInfo info : variableInfos) {
  63       myVariableToInfoMap.put(info.variable, info);
  64     }
  65     myVariableData = new ParameterTablePanel.VariableData[variableInfos.length];
  66
  67     final JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(myProject);
  68     for(int idx = 0; idx < variableInfos.length; idx++){
  69       VariableInfo info = variableInfos[idx];
  70       String name = info.variable.getName();
  71       VariableKind kind = codeStyleManager.getVariableKind(info.variable);
  72       name = codeStyleManager.variableNameToPropertyName(name, kind);
  73       name = codeStyleManager.propertyNameToVariableName(name, VariableKind.PARAMETER);
  74       ParameterTablePanel.VariableData data = new ParameterTablePanel.VariableData(info.variable);
  75       data.name = name;
  76       data.passAsParameter = true;
  77       myVariableData[idx] = data;
  78     }
  79
  80     init();
  81
  82     String name = myAnonClass.getBaseClassReference().getReferenceName();
  83     @NonNls final String prefix = "My";
  84     name = prefix + name; //?
  85     myNameField.setText(name);
  86     myNameField.selectAll();
  87   }
  88
  89   protected Action[] createActions(){
  90     return new Action[]{getOKAction(),getCancelAction(),getHelpAction()};
  91   }
  92
  93   public JComponent getPreferredFocusedComponent() {
  94     return myNameField;
  95   }
  96
  97   public boolean isMakeStatic() {
  98     if(myNeedsThis) {
  99       return false;
 100     }
 101     else {
 102       return myCbMakeStatic.isSelected();
 103     }
 104   }
 105
 106   public String getClassName() {
 107     return myNameField.getText().trim();
 108   }
 109
 110   public VariableInfo[] getVariableInfos() {
 111     JavaCodeStyleManager codeStyleManager = JavaCodeStyleManager.getInstance(myProject);
 112     VariableInfo[] infos = new VariableInfo[myVariableData.length];
 113     for (int idx = 0; idx < myVariableData.length; idx++) {
 114       ParameterTablePanel.VariableData data = myVariableData[idx];
 115       VariableInfo info = myVariableToInfoMap.get(data.variable);
 116
 117       info.passAsParameter = data.passAsParameter;
 118       info.parameterName = data.name;
 119       info.parameterName = data.name;
 120       String propertyName = codeStyleManager.variableNameToPropertyName(data.name, VariableKind.PARAMETER);
 121       info.fieldName = codeStyleManager.propertyNameToVariableName(propertyName, VariableKind.FIELD);
 122
 123       infos[idx] = info;
 124     }
 125     return infos;
 126   }
 127
 128   protected void doOKAction(){
 129     String errorString = null;
 130     final String innerClassName = getClassName();
 131     final PsiManager manager = PsiManager.getInstance(myProject);
 132     if ("".equals(innerClassName)) {
 133       errorString = RefactoringBundle.message("anonymousToInner.no.inner.class.name");
 134     }
 135     else {
 136       if (!JavaPsiFacade.getInstance(manager.getProject()).getNameHelper().isIdentifier(innerClassName)) {
 137         errorString = RefactoringMessageUtil.getIncorrectIdentifierMessage(innerClassName);
 138       }
 139       else{
 140         PsiElement targetContainer = AnonymousToInnerHandler.findTargetContainer(myAnonClass);
 141         if (targetContainer instanceof PsiClass) {
 142           PsiClass targetClass = (PsiClass)targetContainer;
 143           PsiClass[] innerClasses = targetClass.getInnerClasses();
 144           for (PsiClass innerClass : innerClasses) {
 145             if (innerClassName.equals(innerClass.getName())) {
 146               errorString = RefactoringBundle.message("inner.class.exists", innerClassName, targetClass.getName());
 147               break;
 148             }
 149           }
 150         }
 151         else {
 152           LOG.assertTrue(false);
 153         }
 154       }
 155     }
 156
 157     if (errorString != null) {
 158       CommonRefactoringUtil.showErrorMessage(
 159         AnonymousToInnerHandler.REFACTORING_NAME,
 160         errorString,
 161         HelpID.ANONYMOUS_TO_INNER,
 162         myProject);
 163       myNameField.requestFocusInWindow();
 164       return;
 165     }
 166     super.doOKAction();
 167     myNameField.requestFocusInWindow();
 168   }
 169
 170   protected JComponent createNorthPanel() {
 171     JPanel panel = new JPanel(new GridBagLayout());
 172     GridBagConstraints gbConstraints = new GridBagConstraints();
 173
 174     gbConstraints.insets = new Insets(4, 4, 4, 4);
 175     gbConstraints.anchor = GridBagConstraints.EAST;
 176     gbConstraints.fill = GridBagConstraints.BOTH;
 177
 178     gbConstraints.gridwidth = 1;
 179     gbConstraints.weightx = 0;
 180     gbConstraints.weighty = 1;
 181     gbConstraints.gridx = 0;
 182     gbConstraints.gridy = 0;
 183     JLabel namePrompt = new JLabel(RefactoringBundle.message("anonymousToInner.class.name.label.text"));
 184     panel.add(namePrompt, gbConstraints);
 185
 186     myNameField = new EditorTextField("");
 187     gbConstraints.gridwidth = 1;
 188     gbConstraints.weightx = 1;
 189     gbConstraints.gridx = 1;
 190     gbConstraints.gridy = 0;
 191     panel.add(myNameField, gbConstraints);
 192
 193     if(!myNeedsThis) {
 194       myCbMakeStatic = new NonFocusableCheckBox();
 195       myCbMakeStatic.setText(RefactoringBundle.message("anonymousToInner.make.class.static.checkbox.text"));
 196       //myCbMakeStatic.setDisplayedMnemonicIndex(11);
 197       gbConstraints.gridx = 0;
 198       gbConstraints.gridy++;
 199       gbConstraints.gridwidth = 2;
 200       panel.add(myCbMakeStatic, gbConstraints);
 201       myCbMakeStatic.setSelected(true);
 202     }
 203     return panel;
 204   }
 205
 206   private JComponent createParametersPanel() {
 207     JPanel panel = new ParameterTablePanel(myProject, myVariableData, myAnonClass) {
 208       protected void updateSignature() {
 209       }
 210
 211       protected void doEnterAction() {
 212         clickDefaultButton();
 213       }
 214
 215       protected void doCancelAction() {
 216         AnonymousToInnerDialog.this.doCancelAction();
 217       }
 218     };
 219     panel.setBorder(IdeBorderFactory.createTitledBorder(RefactoringBundle.message("anonymousToInner.parameters.panel.border.title")));
 220     return panel;
 221   }
 222
 223   protected JComponent createCenterPanel() {
 224     JPanel panel = new JPanel(new BorderLayout());
 225     panel.add(createParametersPanel(), BorderLayout.CENTER);
 226     return panel;
 227   }
 228
 229   protected void doHelpAction() {
 230     HelpManager.getInstance().invokeHelp(HelpID.ANONYMOUS_TO_INNER);
 231   }
 232 }