java/java-impl/src/com/intellij/application/options/CodeStyleImportsPanel.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 package com.intellij.application.options;
  17
  18 import com.intellij.openapi.application.ApplicationBundle;
  19 import com.intellij.openapi.editor.SyntaxHighlighterColors;
  20 import com.intellij.openapi.editor.markup.TextAttributes;
  21 import com.intellij.openapi.ui.VerticalFlowLayout;
  22 import com.intellij.openapi.ui.ex.MultiLineLabel;
  23 import com.intellij.psi.codeStyle.CodeStyleSettings;
  24 import com.intellij.psi.codeStyle.PackageEntry;
  25 import com.intellij.psi.codeStyle.PackageEntryTable;
  26 import com.intellij.ui.*;
  27 import com.intellij.util.ui.Table;
  28
  29 import javax.swing.*;
  30 import javax.swing.event.*;
  31 import javax.swing.table.*;
  32 import java.awt.*;
  33 import java.awt.event.ActionEvent;
  34 import java.awt.event.ActionListener;
  35 import java.awt.event.ItemEvent;
  36 import java.awt.event.ItemListener;
  37
  38 public class CodeStyleImportsPanel extends JPanel {
  39   private JCheckBox myCbUseFQClassNames;
  40   private JCheckBox myCbUseFQClassNamesInJavaDoc;
  41   private JCheckBox myCbUseSingleClassImports;
  42   private JCheckBox myCbInsertInnerClassImports;
  43   private JTextField myClassCountField;
  44   private JTextField myNamesCountField;
  45   private final PackageEntryTable myImportLayoutList = new PackageEntryTable();
  46   private final PackageEntryTable myPackageList = new PackageEntryTable();
  47
  48   private Table myImportLayoutTable;
  49   private JButton myMoveUpButton;
  50   private JButton myMoveDownButton;
  51   private JButton myRemovePackageFromImportLayoutButton;
  52   private JButton myRemovePackageFromPackagesButton;
  53   private Table myPackageTable;
  54   private final CodeStyleSettings mySettings;
  55   private JRadioButton myJspImportCommaSeparated;
  56   private JRadioButton myJspOneImportPerDirective;
  57
  58   private JPanel myGeneralPanel;
  59   private JPanel myJSPPanel;
  60   private JPanel myPackagesPanel;
  61   private JPanel myImportsLayoutPanel;
  62   private JPanel myWholePanel;
  63   private JCheckBox myCbLayoutStaticImportsSeparately;
  64
  65   public CodeStyleImportsPanel(CodeStyleSettings settings){
  66     mySettings = settings;
  67     setLayout(new BorderLayout());
  68     setBorder(BorderFactory.createEmptyBorder(8, 4, 4, 4));
  69     add(myWholePanel, BorderLayout.CENTER);
  70
  71     myGeneralPanel.add(createGeneralOptionsPanel(), BorderLayout.CENTER);
  72     myJSPPanel.add(createJspImportLayoutPanel(), BorderLayout.CENTER);
  73     myImportsLayoutPanel.add(createImportLayoutPanel(), BorderLayout.NORTH);
  74     myPackagesPanel.add(createPackagesPanel(), BorderLayout.NORTH);
  75   }
  76
  77   private JPanel createJspImportLayoutPanel() {
  78     ButtonGroup buttonGroup = new ButtonGroup();
  79     myJspImportCommaSeparated = new JRadioButton(ApplicationBundle.message("radio.prefer.comma.separated.import.list"));
  80     myJspOneImportPerDirective = new JRadioButton(ApplicationBundle.message("radio.prefer.one.import.statement.per.page.directive"));
  81     buttonGroup.add(myJspImportCommaSeparated);
  82     buttonGroup.add(myJspOneImportPerDirective);
  83     JPanel btnPanel = new JPanel(new BorderLayout());
  84     btnPanel.add(myJspImportCommaSeparated, BorderLayout.NORTH);
  85     btnPanel.add(myJspOneImportPerDirective, BorderLayout.CENTER);
  86
  87     //noinspection HardCodedStringLiteral
  88     final MultiLineLabel commaSeparatedLabel = new MultiLineLabel("<% page import=\"com.company.Boo, \n" +
  89                                                                   "                 com.company.Far\"%>");
  90     //noinspection HardCodedStringLiteral
  91     final MultiLineLabel oneImportPerDirectiveLabel = new MultiLineLabel("<% page import=\"com.company.Boo\"%>\n" +
  92                                                                          "<% page import=\"com.company.Far\"%>");
  93     final JPanel labelPanel = new JPanel(new BorderLayout());
  94     labelPanel.setBorder(IdeBorderFactory.createTitledBorder(ApplicationBundle.message("title.preview")));
  95
  96     JPanel resultPanel = new JPanel(new BorderLayout());
  97     resultPanel.add(btnPanel, BorderLayout.NORTH);
  98     resultPanel.add(labelPanel, BorderLayout.CENTER);
  99     resultPanel.setBorder(IdeBorderFactory.createTitledBorder(ApplicationBundle.message("title.jsp.imports.layout")));
 100
 101
 102     ActionListener actionListener = new ActionListener() {
 103       public void actionPerformed(ActionEvent e) {
 104         boolean isComma = myJspImportCommaSeparated.isSelected();
 105         labelPanel.removeAll();
 106         labelPanel.add(isComma ? commaSeparatedLabel : oneImportPerDirectiveLabel, BorderLayout.CENTER);
 107         labelPanel.repaint();
 108         labelPanel.revalidate();
 109       }
 110     };
 111     myJspImportCommaSeparated.addActionListener(actionListener);
 112     myJspOneImportPerDirective.addActionListener(actionListener);
 113     return resultPanel;
 114   }
 115
 116   private JPanel createGeneralOptionsPanel() {
 117     OptionGroup group = new OptionGroup(ApplicationBundle.message("title.general"));
 118     myCbUseSingleClassImports = new JCheckBox(ApplicationBundle.message("checkbox.use.single.class.import"));
 119     group.add(myCbUseSingleClassImports);
 120
 121     myCbUseFQClassNames = new JCheckBox(ApplicationBundle.message("checkbox.use.fully.qualified.class.names"));
 122     group.add(myCbUseFQClassNames);
 123
 124     myCbInsertInnerClassImports = new JCheckBox(ApplicationBundle.message("checkbox.insert.imports.for.inner.classes"));
 125     group.add(myCbInsertInnerClassImports);
 126
 127     myCbUseFQClassNamesInJavaDoc = new JCheckBox(ApplicationBundle.message("checkbox.use.fully.qualified.class.names.in.javadoc"));
 128     group.add(myCbUseFQClassNamesInJavaDoc);
 129
 130     myClassCountField = new JTextField(3);
 131     myNamesCountField = new JTextField(3);
 132     final JPanel panel = new JPanel(new GridBagLayout());
 133     panel.add(new JLabel(ApplicationBundle.message("editbox.class.count.to.use.import.with.star")), new GridBagConstraints(0, GridBagConstraints.RELATIVE, 1, 1, 0.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(0, 3, 0, 0), 0, 0));
 134     panel.add(myClassCountField, new GridBagConstraints(1, GridBagConstraints.RELATIVE, 1, 1, 1.0, 0.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(0, 1, 0, 0), 0, 0));
 135     panel.add(new JLabel(ApplicationBundle.message("editbox.names.count.to.use.static.import.with.star")), new GridBagConstraints(0, GridBagConstraints.RELATIVE, 1, 1, 0.0, 1.0, GridBagConstraints.WEST, GridBagConstraints.NONE, new Insets(0, 3, 0, 0), 0, 0));
 136     panel.add(myNamesCountField, new GridBagConstraints(1, GridBagConstraints.RELATIVE, 1, 1, 1.0, 1.0, GridBagConstraints.WEST, GridBagConstraints.HORIZONTAL, new Insets(0, 1, 0, 0), 0, 0));
 137
 138     group.add(panel);
 139     return group.createPanel();
 140   }
 141
 142   private JPanel createPackagesPanel() {
 143     JPanel panel = new JPanel(new BorderLayout());
 144     panel.setBorder(IdeBorderFactory.createTitledBorder(ApplicationBundle.message("title.packages.to.use.import.with")));
 145
 146     panel.add(createPackagesTable(), BorderLayout.CENTER);
 147     panel.add(createPackagesButtonsPanel(), BorderLayout.EAST);
 148     panel.setPreferredSize(new Dimension(-1, 200));
 149     return panel;
 150   }
 151
 152   private JPanel createImportLayoutPanel() {
 153     JPanel panel = new JPanel(new BorderLayout());
 154     panel.setBorder(IdeBorderFactory.createTitledBorder(ApplicationBundle.message("title.import.layout")));
 155     myCbLayoutStaticImportsSeparately = new JCheckBox("Layout static imports separately");
 156
 157     myCbLayoutStaticImportsSeparately.addItemListener(new ItemListener(){
 158       public void itemStateChanged(ItemEvent e) {
 159         if (areStaticImportsEnabled()) {
 160           boolean found = false;
 161           for (int i=myImportLayoutList.getEntryCount()-1; i>=0; i--) {
 162             PackageEntry entry = myImportLayoutList.getEntryAt(i);
 163             if (entry == PackageEntry.ALL_OTHER_STATIC_IMPORTS_ENTRY) {
 164               found = true;
 165               break;
 166             }
 167           }
 168           if (!found) {
 169             int index = myImportLayoutList.getEntryCount();
 170             if (index != 0 && myImportLayoutList.getEntryAt(index-1) != PackageEntry.BLANK_LINE_ENTRY) {
 171               myImportLayoutList.addEntry(PackageEntry.BLANK_LINE_ENTRY);
 172             }
 173             myImportLayoutList.addEntry(PackageEntry.ALL_OTHER_STATIC_IMPORTS_ENTRY);
 174           }
 175         }
 176         else {
 177           for (int i=myImportLayoutList.getEntryCount()-1; i>=0; i--) {
 178             PackageEntry entry = myImportLayoutList.getEntryAt(i);
 179             if (entry.isStatic()) {
 180               myImportLayoutList.removeEntryAt(i);
 181             }
 182           }
 183         }
 184         refreshTable(myImportLayoutTable, myImportLayoutList);
 185         refreshTable(myPackageTable, myPackageList);
 186       }
 187     });
 188     panel.add(myCbLayoutStaticImportsSeparately, BorderLayout.NORTH);
 189     panel.add(createImportLayoutTable(), BorderLayout.CENTER);
 190     panel.add(createImportLayoutButtonsPanel(), BorderLayout.EAST);
 191     panel.setPreferredSize(new Dimension(-1, 200));
 192     return panel;
 193   }
 194
 195   private void refreshTable(final Table table, final PackageEntryTable packageTable) {
 196     AbstractTableModel model = (AbstractTableModel)table.getModel();
 197     table.createDefaultColumnsFromModel();
 198     model.fireTableDataChanged();
 199     resizeColumns(packageTable, table);
 200   }
 201
 202   private boolean areStaticImportsEnabled() {
 203     return myCbLayoutStaticImportsSeparately.isSelected();
 204   }
 205
 206   private JPanel createImportLayoutButtonsPanel() {
 207     JPanel tableButtonsPanel = new JPanel();
 208     tableButtonsPanel.setLayout(new BoxLayout(tableButtonsPanel, BoxLayout.Y_AXIS));
 209
 210     JButton addPackageToImportLayoutButton = new JButton(ApplicationBundle.message("button.add.package"));
 211     tableButtonsPanel.add(addPackageToImportLayoutButton);
 212     addPackageToImportLayoutButton.setMaximumSize(new Dimension(Integer.MAX_VALUE, addPackageToImportLayoutButton.getMaximumSize().height));
 213
 214     JButton addBlankLineButton = new JButton(ApplicationBundle.message("button.add.blank"));
 215     tableButtonsPanel.add(addBlankLineButton);
 216     addBlankLineButton.setMaximumSize(new Dimension(Integer.MAX_VALUE, addBlankLineButton.getMaximumSize().height));
 217
 218     myMoveUpButton = new JButton(ApplicationBundle.message("button.move.up"));
 219     tableButtonsPanel.add(myMoveUpButton);
 220     myMoveUpButton.setMaximumSize(new Dimension(Integer.MAX_VALUE, myMoveUpButton.getMaximumSize().height));
 221
 222     myMoveDownButton = new JButton(ApplicationBundle.message("button.move.down"));
 223     tableButtonsPanel.add(myMoveDownButton);
 224     myMoveDownButton.setMaximumSize(new Dimension(Integer.MAX_VALUE, myMoveDownButton.getMaximumSize().height));
 225
 226     myRemovePackageFromImportLayoutButton = new JButton(ApplicationBundle.message("button.remove"));
 227     tableButtonsPanel.add(myRemovePackageFromImportLayoutButton);
 228     myRemovePackageFromImportLayoutButton.setMaximumSize(new Dimension(Integer.MAX_VALUE, myRemovePackageFromImportLayoutButton.getMaximumSize().height));
 229
 230     addPackageToImportLayoutButton.addActionListener(
 231       new ActionListener(){
 232         public void actionPerformed(ActionEvent e){
 233           addPackageToImportLayouts();
 234         }
 235       }
 236     );
 237
 238     addBlankLineButton.addActionListener(
 239       new ActionListener(){
 240         public void actionPerformed(ActionEvent e){
 241           addBlankLine();
 242         }
 243       }
 244     );
 245
 246     myRemovePackageFromImportLayoutButton.addActionListener(
 247       new ActionListener(){
 248         public void actionPerformed(ActionEvent e){
 249           removeEntryFromImportLayouts();
 250         }
 251       }
 252     );
 253
 254     myMoveUpButton.addActionListener(
 255       new ActionListener(){
 256         public void actionPerformed(ActionEvent e){
 257           moveRowUp();
 258         }
 259       }
 260     );
 261
 262     myMoveDownButton.addActionListener(
 263       new ActionListener(){
 264         public void actionPerformed(ActionEvent e){
 265           moveRowDown();
 266         }
 267       }
 268     );
 269
 270     return tableButtonsPanel;
 271   }
 272
 273   private JPanel createPackagesButtonsPanel() {
 274     JPanel tableButtonsPanel = new JPanel();
 275     tableButtonsPanel.setLayout(new BoxLayout(tableButtonsPanel, BoxLayout.Y_AXIS));
 276
 277     JButton addPackageToPackagesButton = new JButton(ApplicationBundle.message("button.add.package.p"));
 278     tableButtonsPanel.add(addPackageToPackagesButton);
 279     addPackageToPackagesButton.setMaximumSize(new Dimension(Integer.MAX_VALUE, addPackageToPackagesButton.getMaximumSize().height));
 280
 281     myRemovePackageFromPackagesButton = new JButton(ApplicationBundle.message("button.remove.r"));
 282     tableButtonsPanel.add(myRemovePackageFromPackagesButton);
 283     myRemovePackageFromPackagesButton.setMaximumSize(new Dimension(Integer.MAX_VALUE, myRemovePackageFromPackagesButton.getMaximumSize().height));
 284
 285     addPackageToPackagesButton.addActionListener(
 286       new ActionListener(){
 287         public void actionPerformed(ActionEvent e){
 288           addPackageToPackages();
 289         }
 290       }
 291     );
 292
 293     myRemovePackageFromPackagesButton.addActionListener(
 294       new ActionListener(){
 295         public void actionPerformed(ActionEvent e){
 296           removeEntryFromPackages();
 297         }
 298       }
 299     );
 300
 301     return tableButtonsPanel;
 302   }
 303
 304   private void addPackageToImportLayouts() {
 305     int selected = myImportLayoutTable.getSelectedRow() + 1;
 306     if(selected < 0) {
 307       selected = myImportLayoutList.getEntryCount();
 308     }
 309     PackageEntry entry = new PackageEntry(false,"", true);
 310     myImportLayoutList.insertEntryAt(entry, selected);
 311     refreshTableModel(selected, myImportLayoutTable);
 312   }
 313
 314   private static void refreshTableModel(int selectedRow, Table table) {
 315     AbstractTableModel model = (AbstractTableModel)table.getModel();
 316     model.fireTableRowsInserted(selectedRow, selectedRow);
 317     table.setRowSelectionInterval(selectedRow, selectedRow);
 318     TableUtil.editCellAt(table, selectedRow, 0);
 319     Component editorComp = table.getEditorComponent();
 320     if(editorComp != null) {
 321       editorComp.requestFocus();
 322     }
 323   }
 324
 325   private void addPackageToPackages() {
 326     int selected = myPackageTable.getSelectedRow() + 1;
 327     if(selected < 0) {
 328       selected = myPackageList.getEntryCount();
 329     }
 330     PackageEntry entry = new PackageEntry(false,"", true);
 331     myPackageList.insertEntryAt(entry, selected);
 332     refreshTableModel(selected, myPackageTable);
 333   }
 334
 335   private void addBlankLine() {
 336     int selected = myImportLayoutTable.getSelectedRow() + 1;
 337     if(selected < 0) {
 338       selected = myImportLayoutList.getEntryCount();
 339     }
 340     myImportLayoutList.insertEntryAt(PackageEntry.BLANK_LINE_ENTRY, selected);
 341     AbstractTableModel model = (AbstractTableModel)myImportLayoutTable.getModel();
 342     model.fireTableRowsInserted(selected, selected);
 343     myImportLayoutTable.setRowSelectionInterval(selected, selected);
 344   }
 345
 346   private void removeEntryFromImportLayouts() {
 347     int selected = myImportLayoutTable.getSelectedRow();
 348     if(selected < 0)
 349       return;
 350     PackageEntry entry = myImportLayoutList.getEntryAt(selected);
 351     if(entry == PackageEntry.ALL_OTHER_STATIC_IMPORTS_ENTRY || entry == PackageEntry.ALL_OTHER_IMPORTS_ENTRY) {
 352       return;
 353     }
 354     TableUtil.stopEditing(myImportLayoutTable);
 355     myImportLayoutList.removeEntryAt(selected);
 356     AbstractTableModel model = (AbstractTableModel)myImportLayoutTable.getModel();
 357     model.fireTableRowsDeleted(selected, selected);
 358     if(selected >= myImportLayoutList.getEntryCount()) {
 359       selected --;
 360     }
 361     if(selected >= 0) {
 362       myImportLayoutTable.setRowSelectionInterval(selected, selected);
 363     }
 364   }
 365
 366   private void removeEntryFromPackages() {
 367     int selected = myPackageTable.getSelectedRow();
 368     if(selected < 0) return;
 369     TableUtil.stopEditing(myPackageTable);
 370     myPackageList.removeEntryAt(selected);
 371     AbstractTableModel model = (AbstractTableModel)myPackageTable.getModel();
 372     model.fireTableRowsDeleted(selected, selected);
 373     if(selected >= myPackageList.getEntryCount()) {
 374       selected --;
 375     }
 376     if(selected >= 0) {
 377       myPackageTable.setRowSelectionInterval(selected, selected);
 378     }
 379   }
 380
 381   private void moveRowUp() {
 382     int selected = myImportLayoutTable.getSelectedRow();
 383     if(selected < 1) {
 384       return;
 385     }
 386     TableUtil.stopEditing(myImportLayoutTable);
 387     PackageEntry entry = myImportLayoutList.getEntryAt(selected);
 388     PackageEntry previousEntry = myImportLayoutList.getEntryAt(selected-1);
 389     myImportLayoutList.setEntryAt(previousEntry, selected);
 390     myImportLayoutList.setEntryAt(entry, selected-1);
 391
 392     AbstractTableModel model = (AbstractTableModel)myImportLayoutTable.getModel();
 393     model.fireTableRowsUpdated(selected-1, selected);
 394     myImportLayoutTable.setRowSelectionInterval(selected-1, selected-1);
 395   }
 396
 397   private void moveRowDown() {
 398     int selected = myImportLayoutTable.getSelectedRow();
 399     if(selected >= myImportLayoutList.getEntryCount()-1) {
 400       return;
 401     }
 402     TableUtil.stopEditing(myImportLayoutTable);
 403     PackageEntry entry = myImportLayoutList.getEntryAt(selected);
 404     PackageEntry nextEntry = myImportLayoutList.getEntryAt(selected+1);
 405     myImportLayoutList.setEntryAt(nextEntry, selected);
 406     myImportLayoutList.setEntryAt(entry, selected+1);
 407
 408     AbstractTableModel model = (AbstractTableModel)myImportLayoutTable.getModel();
 409     model.fireTableRowsUpdated(selected, selected+1);
 410     myImportLayoutTable.setRowSelectionInterval(selected+1, selected+1);
 411   }
 412
 413   private JComponent createPackagesTable() {
 414     myPackageTable = createTableForPackageEntries(myPackageList);
 415     return ScrollPaneFactory.createScrollPane(myPackageTable);
 416   }
 417
 418   private Table createTableForPackageEntries(final PackageEntryTable packageTable) {
 419     final String[] names = {
 420       ApplicationBundle.message("listbox.import.package"),
 421       ApplicationBundle.message("listbox.import.with.subpackages"),
 422     };
 423     // Create a model of the data.
 424     TableModel dataModel = new AbstractTableModel() {
 425       public int getColumnCount() {
 426         return names.length + (areStaticImportsEnabled()?1:0);
 427       }
 428
 429       public int getRowCount() {
 430         return packageTable.getEntryCount();
 431       }
 432
 433       public Object getValueAt(int row, int col) {
 434         PackageEntry entry = packageTable.getEntryAt(row);
 435         if (entry == null || !isCellEditable(row, col)) return null;
 436         col += areStaticImportsEnabled() ? 0 : 1;
 437         if(col == 0) {
 438           return entry.isStatic();
 439         }
 440         if(col == 1) {
 441           return entry.getPackageName();
 442         }
 443         if(col == 2) {
 444           return entry.isWithSubpackages() ? Boolean.TRUE : Boolean.FALSE;
 445         }
 446         throw new IllegalArgumentException(String.valueOf(col));
 447       }
 448
 449       public String getColumnName(int column) {
 450         if (areStaticImportsEnabled() && column == 0) return "Static";
 451         column -= areStaticImportsEnabled() ? 1 : 0;
 452         return names[column];
 453       }
 454
 455       public Class getColumnClass(int col) {
 456         col += areStaticImportsEnabled() ? 0 : 1;
 457         if(col == 0) {
 458           return Boolean.class;
 459         }
 460         if(col == 1) {
 461           return String.class;
 462         }
 463         if(col == 2) {
 464           return Boolean.class;
 465         }
 466         throw new IllegalArgumentException(String.valueOf(col));
 467       }
 468
 469       public boolean isCellEditable(int row, int col) {
 470         PackageEntry packageEntry = packageTable.getEntryAt(row);
 471         return !packageEntry.isSpecial();
 472       }
 473
 474       public void setValueAt(Object aValue, int row, int col) {
 475         PackageEntry packageEntry = packageTable.getEntryAt(row);
 476         col += areStaticImportsEnabled() ? 0 : 1;
 477         if(col == 0) {
 478           PackageEntry newPackageEntry = new PackageEntry((Boolean)aValue, packageEntry.getPackageName(), packageEntry.isWithSubpackages());
 479           packageTable.setEntryAt(newPackageEntry, row);
 480         }
 481         else if(col == 1) {
 482           PackageEntry newPackageEntry = new PackageEntry(packageEntry.isStatic(), ((String)aValue).trim(), packageEntry.isWithSubpackages());
 483           packageTable.setEntryAt(newPackageEntry, row);
 484         }
 485         else if(col == 2) {
 486           PackageEntry newPackageEntry = new PackageEntry(packageEntry.isStatic(), packageEntry.getPackageName(), ((Boolean)aValue).booleanValue());
 487           packageTable.setEntryAt(newPackageEntry, row);
 488         }
 489         else {
 490           throw new IllegalArgumentException(String.valueOf(col));
 491         }
 492       }
 493     };
 494
 495     // Create the table
 496     final Table result = new Table(dataModel);
 497     result.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 498     resizeColumns(packageTable, result);
 499
 500     TableCellEditor editor = result.getDefaultEditor(String.class);
 501     if (editor instanceof DefaultCellEditor) {
 502       ((DefaultCellEditor)editor).setClickCountToStart(1);
 503     }
 504
 505     TableCellEditor beditor = result.getDefaultEditor(Boolean.class);
 506     beditor.addCellEditorListener(new CellEditorListener() {
 507       public void editingStopped(ChangeEvent e) {
 508         if (areStaticImportsEnabled()) {
 509           result.repaint(); // add/remove static keyword
 510         }
 511       }
 512
 513       public void editingCanceled(ChangeEvent e) {
 514       }
 515     });
 516
 517     result.getSelectionModel().addListSelectionListener(
 518       new ListSelectionListener(){
 519         public void valueChanged(ListSelectionEvent e){
 520           updateButtons();
 521         }
 522       }
 523     );
 524
 525     return result;
 526   }
 527
 528   private void resizeColumns(final PackageEntryTable packageTable, Table result) {
 529     ColoredTableCellRenderer packageRenderer = new ColoredTableCellRenderer() {
 530       @Override
 531       protected void customizeCellRenderer(JTable table, Object value, boolean selected, boolean hasFocus, int row, int column) {
 532         PackageEntry entry = packageTable.getEntryAt(row);
 533
 534         if (entry == PackageEntry.BLANK_LINE_ENTRY) {
 535           append("                                               <blank line>", SimpleTextAttributes.LINK_ATTRIBUTES);
 536         }
 537         else {
 538           TextAttributes attributes = SyntaxHighlighterColors.KEYWORD.getDefaultAttributes();
 539           append("import", SimpleTextAttributes.fromTextAttributes(attributes));
 540           if (entry.isStatic()) {
 541             append(" ", SimpleTextAttributes.REGULAR_ATTRIBUTES);
 542             append("static", SimpleTextAttributes.fromTextAttributes(attributes));
 543           }
 544           append(" ", SimpleTextAttributes.REGULAR_ATTRIBUTES);
 545
 546           if (entry == PackageEntry.ALL_OTHER_IMPORTS_ENTRY || entry == PackageEntry.ALL_OTHER_STATIC_IMPORTS_ENTRY) {
 547             append("all other imports", SimpleTextAttributes.REGULAR_ATTRIBUTES);
 548           }
 549           else {
 550             append(entry.getPackageName() + ".*", SimpleTextAttributes.REGULAR_ATTRIBUTES);
 551           }
 552         }
 553       }
 554     };
 555     if (areStaticImportsEnabled()) {
 556       fixColumnWidthToHeader(result, 0);
 557       fixColumnWidthToHeader(result, 2);
 558       result.getColumnModel().getColumn(1).setCellRenderer(packageRenderer);
 559       result.getColumnModel().getColumn(0).setCellRenderer(new BooleanTableCellRenderer());
 560       result.getColumnModel().getColumn(2).setCellRenderer(new BooleanTableCellRenderer());
 561     }
 562     else {
 563       fixColumnWidthToHeader(result, 1);
 564       result.getColumnModel().getColumn(0).setCellRenderer(packageRenderer);
 565       result.getColumnModel().getColumn(1).setCellRenderer(new BooleanTableCellRenderer());
 566     }
 567   }
 568
 569   private static void fixColumnWidthToHeader(Table result, int columnIdx) {
 570     final TableColumn column = result.getColumnModel().getColumn(columnIdx);
 571     final int width = result.getTableHeader().getFontMetrics(result.getTableHeader().getFont()).stringWidth(result.getColumnName(columnIdx)) + 6;
 572     column.setMinWidth(width);
 573     column.setMaxWidth(width);
 574   }
 575
 576   private void updateButtons(){
 577     int selectedImport = myImportLayoutTable.getSelectedRow();
 578     myMoveUpButton.setEnabled(selectedImport >= 1);
 579     myMoveDownButton.setEnabled(selectedImport < myImportLayoutTable.getRowCount()-1);
 580     PackageEntry entry = selectedImport < 0 ? null : myImportLayoutList.getEntryAt(selectedImport);
 581     boolean canRemove =  entry != null && entry != PackageEntry.ALL_OTHER_STATIC_IMPORTS_ENTRY && entry != PackageEntry.ALL_OTHER_IMPORTS_ENTRY;
 582     myRemovePackageFromImportLayoutButton.setEnabled(canRemove);
 583
 584     int selectedPackage = myPackageTable.getSelectedRow();
 585     myRemovePackageFromPackagesButton.setEnabled(selectedPackage >= 0);
 586   }
 587
 588   private JComponent createImportLayoutTable() {
 589     myImportLayoutTable = createTableForPackageEntries(myImportLayoutList);
 590     return ScrollPaneFactory.createScrollPane(myImportLayoutTable);
 591   }
 592
 593   public void reset() {
 594     myCbUseFQClassNames.setSelected(mySettings.USE_FQ_CLASS_NAMES);
 595     myCbUseFQClassNamesInJavaDoc.setSelected(mySettings.USE_FQ_CLASS_NAMES_IN_JAVADOC);
 596     myCbUseSingleClassImports.setSelected(mySettings.USE_SINGLE_CLASS_IMPORTS);
 597     myCbInsertInnerClassImports.setSelected(mySettings.INSERT_INNER_CLASS_IMPORTS);
 598     myClassCountField.setText(Integer.toString(mySettings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND));
 599     myNamesCountField.setText(Integer.toString(mySettings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND));
 600
 601     myImportLayoutList.copyFrom(mySettings.IMPORT_LAYOUT_TABLE);
 602     myPackageList.copyFrom(mySettings.PACKAGES_TO_USE_IMPORT_ON_DEMAND);
 603
 604     myCbLayoutStaticImportsSeparately.setSelected(mySettings.LAYOUT_STATIC_IMPORTS_SEPARATELY);
 605
 606     AbstractTableModel model = (AbstractTableModel)myImportLayoutTable.getModel();
 607     model.fireTableDataChanged();
 608
 609     model = (AbstractTableModel)myPackageTable.getModel();
 610     model.fireTableDataChanged();
 611
 612     if(myImportLayoutTable.getRowCount() > 0) {
 613       myImportLayoutTable.getSelectionModel().setSelectionInterval(0, 0);
 614     }
 615     if(myPackageTable.getRowCount() > 0) {
 616       myPackageTable.getSelectionModel().setSelectionInterval(0, 0);
 617     }
 618
 619     if (mySettings.JSP_PREFER_COMMA_SEPARATED_IMPORT_LIST) {
 620       myJspImportCommaSeparated.doClick();
 621     }
 622     else {
 623       myJspOneImportPerDirective.doClick();
 624     }
 625     updateButtons();
 626   }
 627
 628   public void apply() {
 629     stopTableEditing();
 630
 631     mySettings.LAYOUT_STATIC_IMPORTS_SEPARATELY = areStaticImportsEnabled();
 632     mySettings.USE_FQ_CLASS_NAMES = myCbUseFQClassNames.isSelected();
 633     mySettings.USE_FQ_CLASS_NAMES_IN_JAVADOC = myCbUseFQClassNamesInJavaDoc.isSelected();
 634     mySettings.USE_SINGLE_CLASS_IMPORTS = myCbUseSingleClassImports.isSelected();
 635     mySettings.INSERT_INNER_CLASS_IMPORTS = myCbInsertInnerClassImports.isSelected();
 636     try{
 637       mySettings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND = Integer.parseInt(myClassCountField.getText());
 638     }
 639     catch(NumberFormatException e){
 640       //just a bad number
 641     }
 642     try{
 643       mySettings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND = Integer.parseInt(myNamesCountField.getText());
 644     }
 645     catch(NumberFormatException e){
 646       //just a bad number
 647     }
 648
 649     myImportLayoutList.removeEmptyPackages();
 650     mySettings.IMPORT_LAYOUT_TABLE.copyFrom(myImportLayoutList);
 651
 652     myPackageList.removeEmptyPackages();
 653     mySettings.PACKAGES_TO_USE_IMPORT_ON_DEMAND.copyFrom(myPackageList);
 654
 655     mySettings.JSP_PREFER_COMMA_SEPARATED_IMPORT_LIST = myJspImportCommaSeparated.isSelected();
 656   }
 657
 658
 659   private void stopTableEditing() {
 660     TableUtil.stopEditing(myImportLayoutTable);
 661     TableUtil.stopEditing(myPackageTable);
 662   }
 663
 664   public boolean isModified() {
 665     boolean
 666     isModified  = isModified(myCbLayoutStaticImportsSeparately, mySettings.LAYOUT_STATIC_IMPORTS_SEPARATELY);
 667     isModified |= isModified(myCbUseFQClassNames, mySettings.USE_FQ_CLASS_NAMES);
 668     isModified |= isModified(myCbUseFQClassNamesInJavaDoc, mySettings.USE_FQ_CLASS_NAMES_IN_JAVADOC);
 669     isModified |= isModified(myCbUseSingleClassImports, mySettings.USE_SINGLE_CLASS_IMPORTS);
 670     isModified |= isModified(myCbInsertInnerClassImports, mySettings.INSERT_INNER_CLASS_IMPORTS);
 671     isModified |= isModified(myClassCountField, mySettings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND);
 672     isModified |= isModified(myNamesCountField, mySettings.NAMES_COUNT_TO_USE_IMPORT_ON_DEMAND);
 673
 674     isModified |= isModified(myImportLayoutList, mySettings.IMPORT_LAYOUT_TABLE);
 675     isModified |= isModified(myPackageList, mySettings.PACKAGES_TO_USE_IMPORT_ON_DEMAND);
 676     isModified |= mySettings.JSP_PREFER_COMMA_SEPARATED_IMPORT_LIST != myJspImportCommaSeparated.isSelected();
 677
 678     return isModified;
 679   }
 680
 681   private static boolean isModified(JTextField textField, int value) {
 682     try {
 683       int fieldValue = Integer.parseInt(textField.getText().trim());
 684       return fieldValue != value;
 685     }
 686     catch(NumberFormatException e) {
 687       return false;
 688     }
 689   }
 690
 691   private static boolean isModified(JCheckBox checkBox, boolean value) {
 692     return checkBox.isSelected() != value;
 693   }
 694
 695   private static boolean isModified(PackageEntryTable list, PackageEntryTable table) {
 696     if(list.getEntryCount() != table.getEntryCount()) {
 697       return true;
 698     }
 699
 700     for(int i=0; i<list.getEntryCount(); i++) {
 701       PackageEntry entry1 = list.getEntryAt(i);
 702       PackageEntry entry2 = table.getEntryAt(i);
 703       if(!entry1.equals(entry2)) {
 704         return true;
 705       }
 706     }
 707
 708     return false;
 709   }
 710 }