azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Convert to Kotlin: AbstractParameterTablePanel.java

Browse Source
This commit is contained in:
Alexey Sedunov
2016-07-12 20:50:40 +03:00
parent 27773fbe99
commit ce0e5b4b46
2 changed files with 149 additions and 221 deletions
Download Patch File Download Diff File Expand all files Collapse all files
idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/extractFunction/ui/ExtractFunctionParameterTablePanel.kt
+2 -2
View File
@@ -99,7 +99,7 @@ open class ExtractFunctionParameterTablePanel : AbstractParameterTablePanel<Para
private inner class MyTableModel : AbstractParameterTablePanel<Parameter, ParameterInfo>.TableModelBase() { private inner class MyTableModel : AbstractParameterTablePanel<Parameter, ParameterInfo>.TableModelBase() {
override fun getColumnCount() = 3 override fun getColumnCount() = 3
override fun getValueAt(rowIndex: Int, columnIndex: Int): Any { override fun getValueAt(rowIndex: Int, columnIndex: Int): Any? {
if (columnIndex == PARAMETER_TYPE_COLUMN) return parameterInfos[rowIndex].type if (columnIndex == PARAMETER_TYPE_COLUMN) return parameterInfos[rowIndex].type
return super.getValueAt(rowIndex, columnIndex) return super.getValueAt(rowIndex, columnIndex)
} }
@@ -117,7 +117,7 @@ open class ExtractFunctionParameterTablePanel : AbstractParameterTablePanel<Para
override fun isCellEditable(rowIndex: Int, columnIndex: Int): Boolean { override fun isCellEditable(rowIndex: Int, columnIndex: Int): Boolean {
val info = parameterInfos[rowIndex] val info = parameterInfos[rowIndex]
when (columnIndex) { when (columnIndex) {
AbstractParameterTablePanel.TableModelBase.PARAMETER_NAME_COLUMN -> return super.isCellEditable(rowIndex, columnIndex) && !info.isReceiver AbstractParameterTablePanel.PARAMETER_NAME_COLUMN -> return super.isCellEditable(rowIndex, columnIndex) && !info.isReceiver
PARAMETER_TYPE_COLUMN -> return isEnabled && info.isEnabled && info.originalParameter.getParameterTypeCandidates(false).size > 1 PARAMETER_TYPE_COLUMN -> return isEnabled && info.isEnabled && info.originalParameter.getParameterTypeCandidates(false).size > 1
else -> return super.isCellEditable(rowIndex, columnIndex) else -> return super.isCellEditable(rowIndex, columnIndex)
} }
idea/src/org/jetbrains/kotlin/idea/refactoring/introduce/ui/AbstractParameterTablePanel.kt
+147 -219
View File
@@ -14,291 +14,219 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.idea.refactoring.introduce.ui; package org.jetbrains.kotlin.idea.refactoring.introduce.ui
import com.intellij.ui.BooleanTableCellRenderer; import com.intellij.ui.BooleanTableCellRenderer
import com.intellij.ui.TableUtil; import com.intellij.ui.TableUtil
import com.intellij.ui.ToolbarDecorator; import com.intellij.ui.ToolbarDecorator
import com.intellij.ui.table.JBTable; import com.intellij.ui.table.JBTable
import com.intellij.util.ui.EditableModel; import com.intellij.util.ui.EditableModel
import org.jetbrains.annotations.NonNls; import org.jetbrains.annotations.NonNls
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.idea.core.KotlinNameSuggester
import org.jetbrains.kotlin.idea.core.KotlinNameSuggester; import java.awt.BorderLayout
import org.jetbrains.kotlin.idea.refactoring.introduce.extractionEngine.Parameter; import java.awt.Component
import java.awt.Dimension
import java.awt.event.ActionEvent
import java.awt.event.KeyEvent
import javax.swing.*
import javax.swing.table.AbstractTableModel
import javax.swing.*; abstract class AbstractParameterTablePanel<Param, UIParam : AbstractParameterTablePanel.AbstractParameterInfo<Param>> : JPanel(BorderLayout()) {
import javax.swing.table.AbstractTableModel; companion object {
import javax.swing.table.TableCellEditor; val CHECKMARK_COLUMN = 0
import javax.swing.table.TableColumn; val PARAMETER_NAME_COLUMN = 1
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.util.List;
public abstract class AbstractParameterTablePanel<Param, UIParam extends AbstractParameterTablePanel.AbstractParameterInfo<Param>> extends JPanel {
public static abstract class AbstractParameterInfo<Param> {
private final Param originalParameter;
private boolean enabled = true;
private String name;
public AbstractParameterInfo(Param originalParameter) {
this.originalParameter = originalParameter;
}
public Param getOriginalParameter() {
return originalParameter;
}
public boolean isEnabled() {
return enabled;
}
public void setEnabled(boolean enabled) {
this.enabled = enabled;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public abstract Param toParameter();
} }
protected List<UIParam> parameterInfos; abstract class AbstractParameterInfo<out Param>(val originalParameter: Param) {
var isEnabled = true
lateinit var name: String
private JBTable myTable; abstract fun toParameter(): Param
private TableModelBase myTableModel;
public AbstractParameterTablePanel() {
super(new BorderLayout());
} }
protected TableModelBase createTableModel() { protected lateinit var parameterInfos: MutableList<UIParam>
return new TableModelBase();
}
protected void createAdditionalColumns() { lateinit var table: JBTable
private set
protected lateinit var tableModel: TableModelBase
private set
protected open fun createTableModel() = TableModelBase()
protected open fun createAdditionalColumns() {
} }
public void init() { fun init() {
myTableModel = createTableModel(); tableModel = createTableModel()
myTable = new JBTable(myTableModel); table = JBTable(tableModel)
DefaultCellEditor defaultEditor = (DefaultCellEditor) myTable.getDefaultEditor(Object.class);
defaultEditor.setClickCountToStart(1);
myTable.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION); val defaultEditor = table.getDefaultEditor(Any::class.java) as DefaultCellEditor
myTable.setCellSelectionEnabled(true); defaultEditor.clickCountToStart = 1
TableColumn checkBoxColumn = myTable.getColumnModel().getColumn(TableModelBase.CHECKMARK_COLUMN); table.selectionModel.selectionMode = ListSelectionModel.SINGLE_SELECTION
TableUtil.setupCheckboxColumn(checkBoxColumn); table.cellSelectionEnabled = true
checkBoxColumn.setHeaderValue("");
checkBoxColumn.setCellRenderer( with(table.columnModel.getColumn(CHECKMARK_COLUMN)) {
new BooleanTableCellRenderer() { TableUtil.setupCheckboxColumn(this)
@NotNull headerValue = ""
@Override cellRenderer = object : BooleanTableCellRenderer() {
public Component getTableCellRendererComponent( override fun getTableCellRendererComponent(
JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column table: JTable, value: Any?, isSelected: Boolean, hasFocus: Boolean, row: Int, column: Int
) { ): Component {
Component rendererComponent = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column); val rendererComponent = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column)
rendererComponent.setEnabled(AbstractParameterTablePanel.this.isEnabled()); rendererComponent.isEnabled = this@AbstractParameterTablePanel.isEnabled
return rendererComponent; return rendererComponent
}
} }
); }
}
myTable.getColumnModel().getColumn(TableModelBase.PARAMETER_NAME_COLUMN).setHeaderValue("Name"); table.columnModel.getColumn(PARAMETER_NAME_COLUMN).headerValue = "Name"
createAdditionalColumns(); createAdditionalColumns()
myTable.setPreferredScrollableViewportSize(new Dimension(250, myTable.getRowHeight() * 5)); table.preferredScrollableViewportSize = Dimension(250, table.rowHeight * 5)
myTable.setShowGrid(false); table.setShowGrid(false)
myTable.setIntercellSpacing(new Dimension(0, 0)); table.intercellSpacing = Dimension(0, 0)
@NonNls InputMap inputMap = myTable.getInputMap(); @NonNls val inputMap = table.inputMap
@NonNls ActionMap actionMap = myTable.getActionMap(); @NonNls val actionMap = table.actionMap
// SPACE: toggle enable/disable // SPACE: toggle enable/disable
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0), "enable_disable"); inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0), "enable_disable")
actionMap.put("enable_disable", new AbstractAction() { actionMap.put("enable_disable", object : AbstractAction() {
@Override override fun actionPerformed(e: ActionEvent) {
public void actionPerformed(@NotNull ActionEvent e) { if (table.isEditing) return
if (myTable.isEditing()) return; val rows = table.selectedRows
int[] rows = myTable.getSelectedRows(); if (rows.size > 0) {
if (rows.length > 0) { var valueToBeSet = false
boolean valueToBeSet = false; for (row in rows) {
for (int row : rows) { if (!parameterInfos[row].isEnabled) {
if (!parameterInfos.get(row).isEnabled()) { valueToBeSet = true
valueToBeSet = true; break
break;
} }
} }
for (int row : rows) { for (row in rows) {
parameterInfos.get(row).setEnabled(valueToBeSet); parameterInfos[row].isEnabled = valueToBeSet
} }
myTableModel.fireTableRowsUpdated(rows[0], rows[rows.length - 1]); tableModel.fireTableRowsUpdated(rows[0], rows[rows.size - 1])
TableUtil.selectRows(myTable, rows); TableUtil.selectRows(table, rows)
} }
} }
}); })
// make ENTER work when the table has focus // make ENTER work when the table has focus
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "invoke_impl"); inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "invoke_impl")
actionMap.put("invoke_impl", new AbstractAction() { actionMap.put("invoke_impl", object : AbstractAction() {
@Override override fun actionPerformed(e: ActionEvent) {
public void actionPerformed(@NotNull ActionEvent e) { val editor = table.cellEditor
TableCellEditor editor = myTable.getCellEditor();
if (editor != null) { if (editor != null) {
editor.stopCellEditing(); editor.stopCellEditing()
} }
else { else {
onEnterAction(); onEnterAction()
} }
} }
}); })
// make ESCAPE work when the table has focus // make ESCAPE work when the table has focus
actionMap.put("doCancel", new AbstractAction() { actionMap.put("doCancel", object : AbstractAction() {
@Override override fun actionPerformed(e: ActionEvent) {
public void actionPerformed(@NotNull ActionEvent e) { val editor = table.cellEditor
TableCellEditor editor = myTable.getCellEditor();
if (editor != null) { if (editor != null) {
editor.stopCellEditing(); editor.stopCellEditing()
} }
else { else {
onCancelAction(); onCancelAction()
} }
} }
}); })
JPanel listPanel = ToolbarDecorator.createDecorator(myTable).disableAddAction().disableRemoveAction().createPanel(); val listPanel = ToolbarDecorator.createDecorator(table).disableAddAction().disableRemoveAction().createPanel()
add(listPanel, BorderLayout.CENTER); add(listPanel, BorderLayout.CENTER)
} }
protected void updateSignature() { protected open fun updateSignature() {
} }
protected void onEnterAction() { protected open fun onEnterAction() {
} }
protected void onCancelAction() { protected open fun onCancelAction() {
} }
protected class TableModelBase extends AbstractTableModel implements EditableModel { protected open inner class TableModelBase : AbstractTableModel(), EditableModel {
public static final int CHECKMARK_COLUMN = 0; override fun addRow() = throw IllegalAccessError("Not implemented")
public static final int PARAMETER_NAME_COLUMN = 1;
@Override override fun removeRow(index: Int) = throw IllegalAccessError("Not implemented")
public void addRow() {
throw new IllegalAccessError("Not implemented"); override fun exchangeRows(oldIndex: Int, newIndex: Int) {
if (oldIndex < 0 || newIndex < 0) return
if (oldIndex >= parameterInfos.size || newIndex >= parameterInfos.size) return
val old = parameterInfos[oldIndex]
parameterInfos[oldIndex] = parameterInfos[newIndex]
parameterInfos[newIndex] = old
fireTableRowsUpdated(Math.min(oldIndex, newIndex), Math.max(oldIndex, newIndex))
updateSignature()
} }
@Override override fun canExchangeRows(oldIndex: Int, newIndex: Int): Boolean {
public void removeRow(int index) { return when {
throw new IllegalAccessError("Not implemented"); oldIndex < 0 || newIndex < 0 -> false
} oldIndex >= parameterInfos.size || newIndex >= parameterInfos.size -> false
else -> true
@Override
public void exchangeRows(int oldIndex, int newIndex) {
if (oldIndex < 0 || newIndex < 0) return;
if (oldIndex >= parameterInfos.size() || newIndex >= parameterInfos.size()) return;
UIParam old = parameterInfos.get(oldIndex);
parameterInfos.set(oldIndex, parameterInfos.get(newIndex));
parameterInfos.set(newIndex, old);
fireTableRowsUpdated(Math.min(oldIndex, newIndex), Math.max(oldIndex, newIndex));
updateSignature();
}
@Override
public boolean canExchangeRows(int oldIndex, int newIndex) {
if (oldIndex < 0 || newIndex < 0) return false;
if (oldIndex >= parameterInfos.size() || newIndex >= parameterInfos.size()) return false;
return true;
}
@Override
public int getColumnCount() {
return 2;
}
@Override
public int getRowCount() {
return parameterInfos.size();
}
@Override
public Object getValueAt(int rowIndex, int columnIndex) {
switch (columnIndex) {
case CHECKMARK_COLUMN:
return parameterInfos.get(rowIndex).isEnabled();
case PARAMETER_NAME_COLUMN:
return parameterInfos.get(rowIndex).getName();
default:
return null;
} }
} }
@Override override fun getColumnCount() = 2
public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
AbstractParameterInfo info = parameterInfos.get(rowIndex); override fun getRowCount() = parameterInfos.size
switch (columnIndex) {
case CHECKMARK_COLUMN: { override fun getValueAt(rowIndex: Int, columnIndex: Int): Any? {
info.setEnabled((Boolean) aValue); return when (columnIndex) {
fireTableRowsUpdated(rowIndex, rowIndex); CHECKMARK_COLUMN -> parameterInfos[rowIndex].isEnabled
myTable.getSelectionModel().setSelectionInterval(rowIndex, rowIndex); PARAMETER_NAME_COLUMN -> parameterInfos[rowIndex].name
updateSignature(); else -> null
break; }
}
override fun setValueAt(aValue: Any?, rowIndex: Int, columnIndex: Int) {
val info = parameterInfos[rowIndex]
when (columnIndex) {
CHECKMARK_COLUMN -> {
info.isEnabled = aValue as Boolean
fireTableRowsUpdated(rowIndex, rowIndex)
table.selectionModel.setSelectionInterval(rowIndex, rowIndex)
updateSignature()
} }
case PARAMETER_NAME_COLUMN: { PARAMETER_NAME_COLUMN -> {
String name = (String) aValue; val name = aValue as String
if (KotlinNameSuggester.INSTANCE.isIdentifier(name)) { if (KotlinNameSuggester.isIdentifier(name)) {
info.setName(name); info.name = name
} }
updateSignature(); updateSignature()
break;
} }
} }
} }
@Override override fun isCellEditable(rowIndex: Int, columnIndex: Int): Boolean {
public boolean isCellEditable(int rowIndex, int columnIndex) { val info = parameterInfos[rowIndex]
AbstractParameterInfo info = parameterInfos.get(rowIndex); return when (columnIndex) {
switch (columnIndex) { CHECKMARK_COLUMN -> isEnabled
case CHECKMARK_COLUMN: PARAMETER_NAME_COLUMN -> isEnabled && info.isEnabled
return isEnabled(); else -> false
case PARAMETER_NAME_COLUMN:
return isEnabled() && info.isEnabled();
default:
return false;
} }
} }
@NotNull override fun getColumnClass(columnIndex: Int): Class<*> {
@Override if (columnIndex == CHECKMARK_COLUMN) return Boolean::class.java
public Class getColumnClass(int columnIndex) { return super.getColumnClass(columnIndex)
if (columnIndex == CHECKMARK_COLUMN) {
return Boolean.class;
}
return super.getColumnClass(columnIndex);
} }
} }
@NotNull
public JBTable getTable() {
return myTable;
}
@NotNull
public TableModelBase getTableModel() {
return myTableModel;
}
} }