platform/lang-impl/src/com/intellij/refactoring/rename/AutomaticRenamingDialog.java

   1 /*
   2  * Copyright 2000-2009 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
  17 package com.intellij.refactoring.rename;
  18
  19 import com.intellij.navigation.ItemPresentation;
  20 import com.intellij.navigation.NavigationItem;
  21 import com.intellij.openapi.application.ApplicationManager;
  22 import com.intellij.openapi.diagnostic.Logger;
  23 import com.intellij.openapi.project.Project;
  24 import com.intellij.openapi.ui.DialogWrapper;
  25 import com.intellij.openapi.util.Comparing;
  26 import com.intellij.openapi.util.Disposer;
  27 import com.intellij.psi.PsiNamedElement;
  28 import com.intellij.refactoring.RefactoringBundle;
  29 import com.intellij.refactoring.rename.naming.AutomaticRenamer;
  30 import com.intellij.refactoring.ui.EnableDisableAction;
  31 import com.intellij.refactoring.ui.StringTableCellEditor;
  32 import com.intellij.ui.BooleanTableCellRenderer;
  33 import com.intellij.ui.GuiUtils;
  34 import com.intellij.ui.TableUtil;
  35 import com.intellij.usageView.UsageInfo;
  36 import com.intellij.usages.impl.UsagePreviewPanel;
  37 import com.intellij.util.ui.Table;
  38
  39 import javax.swing.*;
  40 import javax.swing.event.ListSelectionEvent;
  41 import javax.swing.event.ListSelectionListener;
  42 import javax.swing.event.TableModelEvent;
  43 import javax.swing.event.TableModelListener;
  44 import javax.swing.table.AbstractTableModel;
  45 import javax.swing.table.TableColumnModel;
  46 import java.awt.*;
  47 import java.awt.event.ActionEvent;
  48 import java.awt.event.ActionListener;
  49 import java.util.*;
  50 import java.util.List;
  51
  52 /**
  53  * @author dsl
  54  */
  55 public class AutomaticRenamingDialog extends DialogWrapper {
  56   private static final Logger LOG = Logger.getInstance("#com.intellij.refactoring.rename.AutomaticRenamingDialog");
  57   private static final int CHECK_COLUMN = 0;
  58   private static final int OLD_NAME_COLUMN = 1;
  59   private static final int NEW_NAME_COLUMN = 2;
  60   private final AutomaticRenamer myRenamer;
  61   private boolean[] myShouldRename;
  62   private String[] myNewNames;
  63   private PsiNamedElement[] myRenames;
  64   private MyTableModel myTableModel;
  65   private Table myTable;
  66   private JPanel myPanelForPreview;
  67   private JButton mySelectAllButton;
  68   private JButton myUnselectAllButton;
  69   private JPanel myPanel;
  70   private JSplitPane mySplitPane;
  71   private final Project myProject;
  72   private final UsagePreviewPanel myUsagePreviewPanel;
  73   private ListSelectionListener myListSelectionListener;
  74
  75   public AutomaticRenamingDialog(Project project, AutomaticRenamer renamer) {
  76     super(project, true);
  77     myProject = project;
  78     myRenamer = renamer;
  79     myUsagePreviewPanel = new UsagePreviewPanel(myProject);
  80     populateData();
  81     setTitle(myRenamer.getDialogTitle());
  82     init();
  83   }
  84
  85   private void populateData() {
  86     final Map<PsiNamedElement, String> renames = myRenamer.getRenames();
  87
  88     List<PsiNamedElement> temp = new ArrayList<PsiNamedElement>();
  89     for (final PsiNamedElement namedElement : renames.keySet()) {
  90       final String newName = renames.get(namedElement);
  91       if (newName != null) temp.add(namedElement);
  92     }
  93
  94     myRenames = temp.toArray(new PsiNamedElement[temp.size()]);
  95     Arrays.sort(myRenames, new Comparator<PsiNamedElement>() {
  96       public int compare(final PsiNamedElement e1, final PsiNamedElement e2) {
  97         return Comparing.compare(e1.getName(), e2.getName());
  98       }
  99     });
 100
 101     myNewNames = new String[myRenames.length];
 102     for (int i = 0; i < myNewNames.length; i++) {
 103       myNewNames[i] = renames.get(myRenames[i]);
 104     }
 105
 106     myShouldRename = new boolean[myRenames.length];
 107     if (myRenamer.isSelectedByDefault()) {
 108       for(int i=0; i<myShouldRename.length; i++) {
 109         myShouldRename [i] = true;
 110       }
 111     }
 112   }
 113
 114   @Override
 115   protected String getDimensionServiceKey() {
 116     return "#com.intellij.refactoring.rename.AutomaticRenamingDialog";
 117   }
 118
 119   protected JComponent createNorthPanel() {
 120     final Box box = Box.createHorizontalBox();
 121     box.add(new JLabel(myRenamer.getDialogDescription()));
 122     box.add(Box.createHorizontalGlue());
 123     return box;
 124   }
 125
 126   public void show() {
 127     if (ApplicationManager.getApplication().isUnitTestMode()) return;
 128     super.show();
 129   }
 130
 131   protected void handleChanges() {
 132   }
 133
 134   protected JComponent createCenterPanel() {
 135     myTableModel = new MyTableModel();
 136     myTable.setModel(myTableModel);
 137     myTableModel.getSpaceAction().register();
 138     myTableModel.addTableModelListener(new TableModelListener() {
 139       public void tableChanged(TableModelEvent e) {
 140         handleChanges();
 141       }
 142     });
 143
 144     final TableColumnModel columnModel = myTable.getColumnModel();
 145     columnModel.getColumn(CHECK_COLUMN).setCellRenderer(new BooleanTableCellRenderer());
 146     final int checkBoxWidth = new JCheckBox().getPreferredSize().width;
 147     columnModel.getColumn(CHECK_COLUMN).setMaxWidth(checkBoxWidth);
 148     columnModel.getColumn(CHECK_COLUMN).setMinWidth(checkBoxWidth);
 149
 150     columnModel.getColumn(NEW_NAME_COLUMN).setCellEditor(new StringTableCellEditor(myProject));
 151     mySelectAllButton.addActionListener(new ActionListener() {
 152       public void actionPerformed(ActionEvent e) {
 153         for (int i = 0; i < myShouldRename.length; i++) {
 154           myShouldRename[i] = true;
 155         }
 156         fireDataChanged();
 157       }
 158     });
 159
 160     myUnselectAllButton.addActionListener(new ActionListener() {
 161       public void actionPerformed(ActionEvent e) {
 162         for (int i = 0; i < myShouldRename.length; i++) {
 163           myShouldRename[i] = false;
 164         }
 165         fireDataChanged();
 166       }
 167     });
 168     myListSelectionListener = new ListSelectionListener() {
 169       public void valueChanged(final ListSelectionEvent e) {
 170         int index = myTable.getSelectionModel().getLeadSelectionIndex();
 171         if (index != -1) {
 172           PsiNamedElement element = myRenames[index];
 173           UsageInfo usageInfo = new UsageInfo(element);
 174           myUsagePreviewPanel.updateLayout(Collections.singletonList(usageInfo));
 175         }
 176         else {
 177           myUsagePreviewPanel.updateLayout(null);
 178         }
 179       }
 180     };
 181     myTable.getSelectionModel().addListSelectionListener(myListSelectionListener);
 182
 183     myPanelForPreview.add(myUsagePreviewPanel, BorderLayout.CENTER);
 184     myUsagePreviewPanel.updateLayout(null);
 185     mySplitPane.setDividerLocation(0.5);
 186
 187     GuiUtils.replaceJSplitPaneWithIDEASplitter(myPanel);
 188
 189     if (myTableModel.getRowCount() != 0) {
 190       myTable.getSelectionModel().addSelectionInterval(0,0);
 191     }
 192     return myPanel;
 193   }
 194
 195   private void fireDataChanged() {
 196     int[] selectedRows = myTable.getSelectedRows();
 197     myTable.getSelectionModel().removeListSelectionListener(myListSelectionListener);
 198
 199     myTableModel.fireTableDataChanged();
 200     for (int selectedRow : selectedRows) {
 201       myTable.addRowSelectionInterval(selectedRow, selectedRow);
 202     }
 203     myTable.getSelectionModel().addListSelectionListener(myListSelectionListener);
 204   }
 205
 206   public JComponent getPreferredFocusedComponent() {
 207     return myTable;
 208   }
 209
 210   protected void doOKAction() {
 211     TableUtil.stopEditing(myTable);
 212     updateRenamer();
 213     super.doOKAction();
 214   }
 215
 216   protected void dispose() {
 217     Disposer.dispose(myUsagePreviewPanel);
 218     super.dispose();
 219   }
 220
 221   private void updateRenamer() {
 222     for (int i = 0; i < myRenames.length; i++) {
 223       PsiNamedElement element = myRenames[i];
 224       if (myShouldRename[i]) {
 225         myRenamer.setRename(element, myNewNames[i]);
 226       }
 227       else {
 228         myRenamer.doNotRename(element);
 229       }
 230     }
 231   }
 232
 233   private class MyTableModel extends AbstractTableModel {
 234     public int getColumnCount() {
 235       return 3;
 236     }
 237
 238     public int getRowCount() {
 239       return myShouldRename.length;
 240     }
 241
 242     public Object getValueAt(int rowIndex, int columnIndex) {
 243       switch(columnIndex) {
 244         case CHECK_COLUMN:
 245           return Boolean.valueOf(myShouldRename[rowIndex]);
 246         case OLD_NAME_COLUMN:
 247           final PsiNamedElement namedElement = myRenames[rowIndex];
 248           String location = null;
 249           if (namedElement instanceof NavigationItem) {
 250             final ItemPresentation presentation = ((NavigationItem)namedElement).getPresentation();
 251             if (presentation != null) {
 252               location = presentation.getLocationString();
 253             }
 254           }
 255           return namedElement.getName() + (location != null ? " " + location : "");
 256         case NEW_NAME_COLUMN:
 257           return myNewNames[rowIndex];
 258         default:
 259           LOG.assertTrue(false);
 260           return null;
 261       }
 262     }
 263
 264     public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
 265       switch(columnIndex) {
 266         case CHECK_COLUMN:
 267           myShouldRename[rowIndex] = ((Boolean)aValue).booleanValue();
 268           break;
 269         case NEW_NAME_COLUMN:
 270           myNewNames[rowIndex] = (String) aValue;
 271           break;
 272         default:
 273           LOG.assertTrue(false);
 274       }
 275       handleChanges();
 276     }
 277
 278     public boolean isCellEditable(int rowIndex, int columnIndex) {
 279       return columnIndex != OLD_NAME_COLUMN;
 280     }
 281
 282     public Class getColumnClass(int columnIndex) {
 283       switch(columnIndex) {
 284         case CHECK_COLUMN: return Boolean.class;
 285         case OLD_NAME_COLUMN: return String.class;
 286         case NEW_NAME_COLUMN: return String.class;
 287         default: return null;
 288       }
 289     }
 290
 291     public String getColumnName(int column) {
 292       switch(column) {
 293         case OLD_NAME_COLUMN:
 294           return RefactoringBundle.message("automatic.renamer.enity.name.column", myRenamer.entityName());
 295         case NEW_NAME_COLUMN:
 296           return RefactoringBundle.message("automatic.renamer.rename.to.column");
 297         default:
 298           return " ";
 299       }
 300     }
 301
 302     private MyEnableDisable getSpaceAction() {
 303       return this.new MyEnableDisable();
 304     }
 305
 306     private class MyEnableDisable extends EnableDisableAction {
 307       protected JTable getTable() {
 308         return myTable;
 309       }
 310
 311       protected boolean isRowChecked(int row) {
 312         return myShouldRename[row];
 313       }
 314
 315       protected void applyValue(int[] rows, boolean valueToBeSet) {
 316         for (final int row : rows) {
 317           myShouldRename[row] = valueToBeSet;
 318         }
 319         fireDataChanged();
 320       }
 321     }
 322   }
 323
 324 }