refactoring/impl/com/intellij/refactoring/memberPullUp/PullUpDialog.java

   1 /*
   2  * Created by IntelliJ IDEA.
   3  * User: dsl
   4  * Date: 18.06.2002
   5  * Time: 13:16:29
   6  * To change template for new class use
   7  * Code Style | Class Templates options (Tools | IDE Options).
   8  */
   9 package com.intellij.refactoring.memberPullUp;
  10
  11 import com.intellij.openapi.help.HelpManager;
  12 import com.intellij.openapi.project.Project;
  13 import com.intellij.openapi.ui.DialogWrapper;
  14 import com.intellij.psi.*;
  15 import com.intellij.refactoring.HelpID;
  16 import com.intellij.refactoring.JavaRefactoringSettings;
  17 import com.intellij.refactoring.RefactoringBundle;
  18 import com.intellij.refactoring.classMembers.MemberInfoChange;
  19 import com.intellij.refactoring.ui.ClassCellRenderer;
  20 import com.intellij.refactoring.ui.MemberSelectionPanel;
  21 import com.intellij.refactoring.util.RefactoringHierarchyUtil;
  22 import com.intellij.refactoring.util.classMembers.InterfaceContainmentVerifier;
  23 import com.intellij.refactoring.util.classMembers.MemberInfo;
  24 import com.intellij.refactoring.util.classMembers.MemberInfoStorage;
  25 import com.intellij.refactoring.util.classMembers.UsesAndInterfacesDependencyMemberInfoModel;
  26 import com.intellij.ui.IdeBorderFactory;
  27 import com.intellij.usageView.UsageViewUtil;
  28 import org.jetbrains.annotations.NotNull;
  29
  30 import javax.swing.*;
  31 import java.awt.*;
  32 import java.awt.event.ItemEvent;
  33 import java.awt.event.ItemListener;
  34 import java.util.ArrayList;
  35 import java.util.List;
  36
  37 public class PullUpDialog extends DialogWrapper {
  38   private final Callback myCallback;
  39   private MemberSelectionPanel myMemberSelectionPanel;
  40   private MyMemberInfoModel myMemberInfoModel;
  41   private final PsiClass myClass;
  42   private final List<PsiClass> mySuperClasses;
  43   private final MemberInfoStorage myMemberInfoStorage;
  44   private List<MemberInfo> myMemberInfos;
  45   private JavaDocPanel myJavaDocPanel;
  46
  47   private JComboBox myClassCombo;
  48
  49   public static interface Callback {
  50     boolean checkConflicts(PullUpDialog dialog);
  51   }
  52
  53
  54   public PullUpDialog(Project project, PsiClass aClass, List<PsiClass> superClasses,
  55                       MemberInfoStorage memberInfoStorage, Callback callback) {
  56     super(project, true);
  57     myClass = aClass;
  58     mySuperClasses = superClasses;
  59     myMemberInfoStorage = memberInfoStorage;
  60     myMemberInfos = myMemberInfoStorage.getClassMemberInfos(aClass);
  61     myCallback = callback;
  62
  63     setTitle(JavaPullUpHandler.REFACTORING_NAME);
  64
  65     init();
  66   }
  67
  68   public PsiClass getSuperClass() {
  69     if (myClassCombo != null) {
  70       return (PsiClass) myClassCombo.getSelectedItem();
  71     }
  72     else {
  73       return null;
  74     }
  75   }
  76
  77   public int getJavaDocPolicy() {
  78     return myJavaDocPanel.getPolicy();
  79   }
  80
  81   public MemberInfo[] getSelectedMemberInfos() {
  82     ArrayList<MemberInfo> list = new ArrayList<MemberInfo>(myMemberInfos.size());
  83     for (MemberInfo info : myMemberInfos) {
  84       if (info.isChecked() && myMemberInfoModel.isMemberEnabled(info)) {
  85         list.add(info);
  86       }
  87     }
  88     return list.toArray(new MemberInfo[list.size()]);
  89   }
  90
  91   protected String getDimensionServiceKey() {
  92     return "#com.intellij.refactoring.memberPullUp.PullUpDialog";
  93   }
  94
  95   InterfaceContainmentVerifier getContainmentVerifier() {
  96     return myInterfaceContainmentVerifier;
  97   }
  98
  99   protected JComponent createNorthPanel() {
 100     JPanel panel = new JPanel();
 101
 102     panel.setBorder(IdeBorderFactory.createBorder());
 103
 104     panel.setLayout(new GridBagLayout());
 105     GridBagConstraints gbConstraints = new GridBagConstraints();
 106
 107     gbConstraints.insets = new Insets(4, 8, 4, 8);
 108     gbConstraints.weighty = 1;
 109     gbConstraints.weightx = 1;
 110     gbConstraints.gridy = 0;
 111     gbConstraints.gridwidth = GridBagConstraints.REMAINDER;
 112     gbConstraints.fill = GridBagConstraints.BOTH;
 113     gbConstraints.anchor = GridBagConstraints.WEST;
 114     final JLabel classComboLabel = new JLabel();
 115     panel.add(classComboLabel, gbConstraints);
 116
 117     myClassCombo = new JComboBox(mySuperClasses.toArray());
 118     myClassCombo.setRenderer(new ClassCellRenderer());
 119     classComboLabel.setText(RefactoringBundle.message("pull.up.members.to", UsageViewUtil.getLongName(myClass)));
 120     classComboLabel.setLabelFor(myClassCombo);
 121 //    myClassCombo.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 122
 123     PsiClass nearestBase = RefactoringHierarchyUtil.getNearestBaseClass(myClass, false);
 124     int indexToSelect = 0;
 125     if (nearestBase != null) {
 126       indexToSelect = mySuperClasses.indexOf(nearestBase);
 127     }
 128     myClassCombo.setSelectedIndex(indexToSelect);
 129     myClassCombo.addItemListener(new ItemListener() {
 130       public void itemStateChanged(ItemEvent e) {
 131         if (e.getStateChange() == ItemEvent.SELECTED) {
 132           updateMemberInfo();
 133           if (myMemberSelectionPanel != null) {
 134             myMemberInfoModel.setSuperClass(getSuperClass());
 135             myMemberSelectionPanel.getTable().setMemberInfos(myMemberInfos);
 136             myMemberSelectionPanel.getTable().fireExternalDataChange();
 137           }
 138         }
 139       }
 140     });
 141     gbConstraints.gridy++;
 142     panel.add(myClassCombo, gbConstraints);
 143
 144     return panel;
 145   }
 146
 147   protected void doHelpAction() {
 148     HelpManager.getInstance().invokeHelp(HelpID.MEMBERS_PULL_UP);
 149   }
 150
 151   private void updateMemberInfo() {
 152     final PsiClass targetClass = (PsiClass) myClassCombo.getSelectedItem();
 153     myMemberInfos = myMemberInfoStorage.getMemberInfosList(targetClass);
 154     /*Set duplicated = myMemberInfoStorage.getDuplicatedMemberInfos(targetClass);
 155     for (Iterator iterator = duplicated.getSectionsIterator(); getSectionsIterator.hasNext();) {
 156       ((MemberInfo) iterator.next()).setChecked(false);
 157     }*/
 158   }
 159
 160   protected void doOKAction() {
 161     if (!myCallback.checkConflicts(this)) return;
 162     JavaRefactoringSettings.getInstance().PULL_UP_MEMBERS_JAVADOC = myJavaDocPanel.getPolicy();
 163     close(OK_EXIT_CODE);
 164   }
 165
 166   protected JComponent createCenterPanel() {
 167     JPanel panel = new JPanel(new BorderLayout());
 168     myMemberSelectionPanel = new MemberSelectionPanel(RefactoringBundle.message("members.to.be.pulled.up"), myMemberInfos, RefactoringBundle.message("make.abstract"));
 169     myMemberInfoModel = new MyMemberInfoModel();
 170     myMemberInfoModel.memberInfoChanged(new MemberInfoChange<PsiMember, MemberInfo>(myMemberInfos));
 171     myMemberSelectionPanel.getTable().setMemberInfoModel(myMemberInfoModel);
 172     myMemberSelectionPanel.getTable().addMemberInfoChangeListener(myMemberInfoModel);
 173     panel.add(myMemberSelectionPanel, BorderLayout.CENTER);
 174
 175     myJavaDocPanel = new JavaDocPanel(RefactoringBundle.message("javadoc.for.abstracts"));
 176     myJavaDocPanel.setPolicy(JavaRefactoringSettings.getInstance().PULL_UP_MEMBERS_JAVADOC);
 177     panel.add(myJavaDocPanel, BorderLayout.EAST);
 178     return panel;
 179   }
 180   private final InterfaceContainmentVerifier myInterfaceContainmentVerifier =
 181     new InterfaceContainmentVerifier() {
 182       public boolean checkedInterfacesContain(PsiMethod psiMethod) {
 183         return PullUpHelper.checkedInterfacesContain(myMemberInfos, psiMethod);
 184       }
 185     };
 186
 187   private class MyMemberInfoModel extends UsesAndInterfacesDependencyMemberInfoModel {
 188     public MyMemberInfoModel() {
 189       super(myClass, getSuperClass(), false, myInterfaceContainmentVerifier);
 190     }
 191
 192
 193     public boolean isMemberEnabled(MemberInfo member) {
 194       PsiClass currentSuperClass = getSuperClass();
 195       if(currentSuperClass == null) return true;
 196       if (myMemberInfoStorage.getDuplicatedMemberInfos(currentSuperClass).contains(member)) return false;
 197       if (myMemberInfoStorage.getExtending(currentSuperClass).contains(member.getMember())) return false;
 198       if (!currentSuperClass.isInterface()) return true;
 199
 200       PsiElement element = member.getMember();
 201       if (element instanceof PsiClass && ((PsiClass) element).isInterface()) return true;
 202       if (element instanceof PsiField) {
 203         return ((PsiModifierListOwner) element).hasModifierProperty(PsiModifier.STATIC);
 204       }
 205       if (element instanceof PsiMethod) {
 206         return !((PsiModifierListOwner) element).hasModifierProperty(PsiModifier.STATIC);
 207       }
 208       return true;
 209     }
 210
 211     public boolean isAbstractEnabled(MemberInfo member) {
 212       PsiClass currentSuperClass = getSuperClass();
 213       if (currentSuperClass == null || !currentSuperClass.isInterface()) return true;
 214       return false;
 215     }
 216
 217     public boolean isAbstractWhenDisabled(MemberInfo member) {
 218       PsiClass currentSuperClass = getSuperClass();
 219       if(currentSuperClass == null) return false;
 220       if (currentSuperClass.isInterface()) {
 221         if (member.getMember() instanceof PsiMethod) {
 222           return true;
 223         }
 224       }
 225       return false;
 226     }
 227
 228     public int checkForProblems(@NotNull MemberInfo member) {
 229       if (member.isChecked()) return OK;
 230       PsiClass currentSuperClass = getSuperClass();
 231
 232       if (currentSuperClass != null && currentSuperClass.isInterface()) {
 233         PsiElement element = member.getMember();
 234         if (element instanceof PsiModifierListOwner) {
 235           if (((PsiModifierListOwner) element).hasModifierProperty(PsiModifier.STATIC)) {
 236             return super.checkForProblems(member);
 237           }
 238         }
 239         return OK;
 240       }
 241       else {
 242         return super.checkForProblems(member);
 243       }
 244     }
 245
 246     public Boolean isFixedAbstract(MemberInfo member) {
 247       return Boolean.TRUE;
 248     }
 249   }
 250 }