/**
* This method updates the input and action maps with new ToggleAction.
*
* @param isToggleDynamic
* @param isToggleLarger
* @param key
* @param keyStroke
*/
private void installToggleAction(
boolean isToggleDynamic, boolean isToggleLarger, String key, String keyStroke) {
Action action = new ToggleAction(isToggleDynamic, isToggleLarger);
KeyStroke ks = KeyStroke.getKeyStroke(keyStroke);
table.getInputMap().put(ks, key);
table.getActionMap().put(key, action);
}
/**
* Luo tilikarttataulukon.
*
* @param container taulukon säiliö
*/
private void createTable() {
tableModel = new DocumentTypeTableModel();
tableModel.setModel(model);
table = new JTable(tableModel);
table.setFillsViewportHeight(true);
table.setPreferredScrollableViewportSize(new Dimension(400, 250));
table.setRowHeight(24);
TableColumn column;
int[] widths = new int[] {80, 140, 80, 80};
for (int i = 0; i < widths.length; i++) {
column = table.getColumnModel().getColumn(i);
column.setPreferredWidth(widths[i]);
}
/* Muutetaan enter-näppäimen toiminta. */
table
.getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
.put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "nextCell");
table.getActionMap().put("nextCell", nextCellAction);
add(
new JScrollPane(
table,
JScrollPane.VERTICAL_SCROLLBAR_AS_NEEDED,
JScrollPane.HORIZONTAL_SCROLLBAR_NEVER),
BorderLayout.CENTER);
}
private static JTable createUITable(
boolean keyColumnResizable, int typeWidth, Type type, List<String> lst, Actions editAction) {
String[] keys = lst.toArray(new String[lst.size()]);
Arrays.sort(keys);
TableModel mdl = type == null ? new UITableModel(keys) : new UITypeTableModel(keys, type, true);
JTable table = new UITable(mdl, null);
table.putClientProperty("JTable.autoStartsEdit", Boolean.FALSE);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setRowHeight(25);
TableColumnModel columns = table.getColumnModel();
int keyWidth = TABLE_WIDTH - typeWidth - VALUE_WIDTH - DEFAULT_WIDTH;
columns.getColumn(UITableModel.KEY_COLUMN_INDEX).setMinWidth(keyWidth);
columns.getColumn(UITableModel.KEY_COLUMN_INDEX).setPreferredWidth(keyWidth);
columns.getColumn(UITableModel.KEY_COLUMN_INDEX).setResizable(keyColumnResizable);
Creator.setWidth(columns.getColumn(UITableModel.TYPE_COLUMN_INDEX), typeWidth);
TableColumn column = columns.getColumn(UITableModel.VALUE_COLUMN_INDEX);
Creator.setWidth(column, VALUE_WIDTH);
column.setCellRenderer(new UIDefaultsRenderer());
column.setCellEditor(new UIDefaultsEditor());
Creator.setWidth(columns.getColumn(UITableModel.DEFAULT_COLUMN_INDEX), DEFAULT_WIDTH);
table.setAutoCreateRowSorter(true);
DefaultRowSorter<?, ?> sorter = (DefaultRowSorter<?, ?>) table.getRowSorter();
sorter.setSortable(UITableModel.VALUE_COLUMN_INDEX, false);
table
.getInputMap(JComponent.WHEN_FOCUSED)
.put(KeyStroke.getKeyStroke(KeyEvent.VK_CONTEXT_MENU, 0), editAction);
table.getActionMap().put(editAction, editAction);
return table;
}
/**
* This method updates the input and action maps with a new ColumnAction.
*
* @param isSelectedColumn
* @param isAdjust
* @param key
* @param keyStroke
*/
private void installColumnAction(
boolean isSelectedColumn, boolean isAdjust, String key, String keyStroke) {
Action action = new ColumnAction(isSelectedColumn, isAdjust);
KeyStroke ks = KeyStroke.getKeyStroke(keyStroke);
table.getInputMap().put(ks, key);
table.getActionMap().put(key, action);
}
@Override
protected void configureTable(JTable table) {
super.configureTable(table);
// replace default action on enter
table
.getActionMap()
.put(
"selectNextRowCell",
new AbstractAction() {
@Override
public void actionPerformed(ActionEvent ae) {}
});
table.addKeyListener(
new KeyAdapter() {
@Override
public void keyReleased(KeyEvent ke) {
switch (ke.getKeyCode()) {
// press enter
case 10:
getOpenDialogExecutor().execute();
break;
// press delete
case 127:
deleteSelected();
refresh();
break;
}
}
});
}
private JPanel createPanel() {
table.setFillsViewportHeight(true);
table.setFont(getMonospacedFont());
table.addMouseListener(
new MouseAdapter() {
public void mouseClicked(java.awt.event.MouseEvent e) {
if (e.getClickCount() == 2 && e.getButton() == MouseEvent.BUTTON1) {
final int viewRow = table.rowAtPoint(e.getPoint());
if (viewRow != -1) {
final int modelRow = table.convertRowIndexToModel(viewRow);
final Breakpoint breakPoint = tableModel.getBreakpoint(modelRow);
disView.setViewStartingAddress(breakPoint.getAddress());
if (sourceLevelDebugView
!= null) { // may be NULL when debugging a plain object file without attached
// source
sourceLevelDebugView.scrollToVisible(breakPoint.getAddress());
}
}
}
};
});
table
.getActionMap()
.put(
"deleteRow",
new AbstractAction("deleteRow") {
public void actionPerformed(ActionEvent e) {
final int viewRow = table.getSelectedRow();
final int modelRow = table.convertRowIndexToModel(viewRow);
Breakpoint bp = tableModel.getBreakpoint(modelRow);
emulator.deleteBreakpoint(bp);
}
});
final KeyStroke stroke = KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0);
table.getInputMap().put(stroke, "deleteRow");
setColors(table);
// setup scrollpane
final JScrollPane pane = new JScrollPane(table);
setColors(pane);
// setup result panel
final JPanel panel = new JPanel();
setColors(panel);
panel.setLayout(new GridBagLayout());
final GridBagConstraints cnstrs = constraints(0, 0, true, true, GridBagConstraints.BOTH);
panel.add(pane, cnstrs);
return panel;
}
private static void registerSortMnemonics(JTable t) {
for (int col = t.getColumnCount(); --col >= 0; ) {
String name = t.getColumnName(col);
int idx = name.indexOf('\u0332');
if (idx > 0) {
int mnemonic = (int) Character.toUpperCase(name.charAt(idx - 1));
Actions act = new Actions(Actions.SORT);
act.putValue(Actions.SORT, name);
t.getInputMap(JComponent.WHEN_FOCUSED)
.put(KeyStroke.getKeyStroke(mnemonic, InputEvent.ALT_DOWN_MASK), act);
t.getActionMap().put(act, act);
}
}
}
// {{{ InstallPanel constructor
InstallPanel(PluginManager window, boolean updates) {
super(new BorderLayout(12, 12));
this.window = window;
this.updates = updates;
setBorder(new EmptyBorder(12, 12, 12, 12));
final JSplitPane split = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
split.setResizeWeight(0.75);
/* Setup the table */
table = new JTable(pluginModel = new PluginTableModel());
table.setShowGrid(false);
table.setIntercellSpacing(new Dimension(0, 0));
table.setRowHeight(table.getRowHeight() + 2);
table.setPreferredScrollableViewportSize(new Dimension(500, 200));
table.setDefaultRenderer(
Object.class,
new TextRenderer((DefaultTableCellRenderer) table.getDefaultRenderer(Object.class)));
table.addFocusListener(new TableFocusHandler());
InputMap tableInputMap = table.getInputMap(JComponent.WHEN_FOCUSED);
ActionMap tableActionMap = table.getActionMap();
tableInputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0), "tabOutForward");
tableActionMap.put("tabOutForward", new KeyboardAction(KeyboardCommand.TAB_OUT_FORWARD));
tableInputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, InputEvent.SHIFT_MASK), "tabOutBack");
tableActionMap.put("tabOutBack", new KeyboardAction(KeyboardCommand.TAB_OUT_BACK));
tableInputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0), "editPlugin");
tableActionMap.put("editPlugin", new KeyboardAction(KeyboardCommand.EDIT_PLUGIN));
tableInputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "closePluginManager");
tableActionMap.put(
"closePluginManager", new KeyboardAction(KeyboardCommand.CLOSE_PLUGIN_MANAGER));
TableColumn col1 = table.getColumnModel().getColumn(0);
TableColumn col2 = table.getColumnModel().getColumn(1);
TableColumn col3 = table.getColumnModel().getColumn(2);
TableColumn col4 = table.getColumnModel().getColumn(3);
TableColumn col5 = table.getColumnModel().getColumn(4);
col1.setPreferredWidth(30);
col1.setMinWidth(30);
col1.setMaxWidth(30);
col1.setResizable(false);
col2.setPreferredWidth(180);
col3.setPreferredWidth(130);
col4.setPreferredWidth(70);
col5.setPreferredWidth(70);
JTableHeader header = table.getTableHeader();
header.setReorderingAllowed(false);
header.addMouseListener(new HeaderMouseHandler());
header.setDefaultRenderer(
new HeaderRenderer((DefaultTableCellRenderer) header.getDefaultRenderer()));
scrollpane = new JScrollPane(table);
scrollpane.getViewport().setBackground(table.getBackground());
split.setTopComponent(scrollpane);
/* Create description */
JScrollPane infoPane = new JScrollPane(infoBox = new PluginInfoBox());
infoPane.setPreferredSize(new Dimension(500, 100));
split.setBottomComponent(infoPane);
EventQueue.invokeLater(
new Runnable() {
@Override
public void run() {
split.setDividerLocation(0.75);
}
});
final JTextField searchField = new JTextField();
searchField.addKeyListener(
new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == KeyEvent.VK_DOWN || e.getKeyCode() == KeyEvent.VK_UP) {
table.dispatchEvent(e);
table.requestFocus();
}
}
});
searchField
.getDocument()
.addDocumentListener(
new DocumentListener() {
void update() {
pluginModel.setFilterString(searchField.getText());
}
@Override
public void changedUpdate(DocumentEvent e) {
update();
}
@Override
public void insertUpdate(DocumentEvent e) {
update();
}
@Override
public void removeUpdate(DocumentEvent e) {
update();
}
});
table.addKeyListener(
new KeyAdapter() {
@Override
public void keyPressed(KeyEvent e) {
int i = table.getSelectedRow(), n = table.getModel().getRowCount();
if (e.getKeyCode() == KeyEvent.VK_DOWN && i == (n - 1)
|| e.getKeyCode() == KeyEvent.VK_UP && i == 0) {
searchField.requestFocus();
searchField.selectAll();
}
}
});
Box filterBox = Box.createHorizontalBox();
filterBox.add(new JLabel("Filter : "));
filterBox.add(searchField);
add(BorderLayout.NORTH, filterBox);
add(BorderLayout.CENTER, split);
/* Create buttons */
Box buttons = new Box(BoxLayout.X_AXIS);
buttons.add(new InstallButton());
buttons.add(Box.createHorizontalStrut(12));
buttons.add(new SelectallButton());
buttons.add(chooseButton = new ChoosePluginSet());
buttons.add(new ClearPluginSet());
buttons.add(Box.createGlue());
buttons.add(new SizeLabel());
add(BorderLayout.SOUTH, buttons);
String path = jEdit.getProperty(PluginManager.PROPERTY_PLUGINSET, "");
if (!path.isEmpty()) {
loadPluginSet(path);
}
} // }}}
public LeksikonaEditorsFrame(Lexicon _lexicon) {
this.lexicon = _lexicon;
JPanel panelis = (JPanel) this.getContentPane();
// panelis.setMaximumSize(new Dimension(820, 672));
panelis.setMinimumSize(new Dimension(820, 610));
// this.setLocale(java.util.Locale.getDefault());
this.setPreferredSize(new Dimension(820, 610));
this.setTitle("Leksikona redaktors");
// this.setResizable(false);
panelis.setLayout(new BorderLayout());
vgrMod = new VardgrupuModelis(lexicon);
vārdgrupas = new JTable(vgrMod);
vārdgrupas.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
TableColumn column = null;
for (int i = 0; i < vgrMod.getColumnCount(); i++) {
column = vārdgrupas.getColumnModel().getColumn(i);
if (i == 1) {
column.setPreferredWidth(300); // third column is bigger
} else {
column.setPreferredWidth(50);
}
}
vārdgrupas
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"deleteRow");
vārdgrupas
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_INSERT, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"insertRow");
vārdgrupas
.getActionMap()
.put(
"deleteRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
deleteWGroup(vārdgrupas.convertRowIndexToModel(vārdgrupas.getSelectedRow()));
}
});
vārdgrupas
.getActionMap()
.put(
"insertRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
insertWGroup();
}
});
vārdgrupas.setBorder(BorderFactory.createLineBorder(Color.black));
vārdgrupas
.getSelectionModel()
.addListSelectionListener(
new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
vārdgrupaSelektēta();
}
});
vgrĪpMod = new AttributeModel(null);
vgrĪpašībuTabula = new IpasibuTable(vgrĪpMod);
vgrĪpašībuTabula.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
vgrĪpašībuTabula.setBorder(BorderFactory.createLineBorder(Color.black));
vgrĪpašībuTabula
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"deleteRow");
vgrĪpašībuTabula
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_INSERT, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"insertRow");
vgrĪpašībuTabula
.getActionMap()
.put(
"deleteRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
deleteWgroupProperty(
vgrĪpašībuTabula.convertRowIndexToModel(vgrĪpašībuTabula.getSelectedRow()));
}
});
vgrĪpašībuTabula
.getActionMap()
.put(
"insertRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
addWgroupProperty();
}
});
galMod = new EndingModel();
galotņuTabula = new JTable(galMod);
galotņuTabula.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
// galotņuTabula.setPreferredScrollableViewportSize(new Dimension(500, 70));
galotņuTabula.setBorder(BorderFactory.createLineBorder(Color.black));
galotņuTabula
.getSelectionModel()
.addListSelectionListener(
new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
galotneSelektēta();
}
});
galotņuTabula
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"deleteRow");
galotņuTabula
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_INSERT, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"insertRow");
galotņuTabula
.getActionMap()
.put(
"deleteRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
deleteEnding(galotņuTabula.convertRowIndexToModel(galotņuTabula.getSelectedRow()));
}
});
galotņuTabula
.getActionMap()
.put(
"insertRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
addEnding();
}
});
galĪpMod = new AttributeModel(null);
galotņuĪpašībuTabula = new IpasibuTable(galĪpMod);
galotņuĪpašībuTabula.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
// galotņuĪpašībuTabula.setPreferredScrollableViewportSize(new Dimension(500, 70));
galotņuĪpašībuTabula.setBorder(BorderFactory.createLineBorder(Color.black));
galotņuĪpašībuTabula
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"deleteRow");
galotņuĪpašībuTabula
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_INSERT, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"insertRow");
galotņuĪpašībuTabula
.getActionMap()
.put(
"deleteRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
deleteEndingProperty(
galotņuĪpašībuTabula.convertRowIndexToModel(
galotņuĪpašībuTabula.getSelectedRow()));
}
});
galotņuĪpašībuTabula
.getActionMap()
.put(
"insertRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
addEndingProperty();
}
});
leksMod = new LexemeModel();
leksēmuTabula = new JTable(leksMod);
leksēmuTabula.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
leksēmuTabula.setBorder(BorderFactory.createLineBorder(Color.black));
// leksēmuTabula.setAutoCreateRowSorter(true);
leksēmuTabula
.getSelectionModel()
.addListSelectionListener(
new ListSelectionListener() {
public void valueChanged(ListSelectionEvent e) {
leksēmaSelektēta();
}
});
leksēmuTabula
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"deleteRow");
leksēmuTabula
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_INSERT, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"insertRow");
leksēmuTabula
.getActionMap()
.put(
"deleteRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
deleteLexeme(leksēmuTabula.convertRowIndexToModel(leksēmuTabula.getSelectedRow()));
}
});
leksēmuTabula
.getActionMap()
.put(
"insertRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
addLexeme();
}
});
leksĪpMod = new AttributeModel(null);
leksēmuĪpašībuTabula = new IpasibuTable(leksĪpMod);
leksēmuĪpašībuTabula.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
leksēmuĪpašībuTabula.setBorder(BorderFactory.createLineBorder(Color.black));
leksēmuĪpašībuTabula
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"deleteRow");
leksēmuĪpašībuTabula
.getInputMap()
.put(
KeyStroke.getKeyStroke(KeyEvent.VK_INSERT, java.awt.event.InputEvent.CTRL_DOWN_MASK),
"insertRow");
leksēmuĪpašībuTabula
.getActionMap()
.put(
"deleteRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
deleteLexemeProperty(
leksēmuĪpašībuTabula.convertRowIndexToModel(
leksēmuĪpašībuTabula.getSelectedRow()));
}
});
leksēmuĪpašībuTabula
.getActionMap()
.put(
"insertRow",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
addLexemeProperty();
}
});
JPanel leja = new JPanel(new BorderLayout());
JPanel pnlVgrTab = new JPanel(new BorderLayout());
JPanel pnlVgrĪpTab = new JPanel(new BorderLayout());
JPanel pnlGalTab = new JPanel(new BorderLayout());
JPanel pnlGalĪpTab = new JPanel(new BorderLayout());
JPanel pnlLeksTab = new JPanel(new BorderLayout());
JPanel pnlLeksĪpTab = new JPanel(new BorderLayout());
pnlVgrTab.add(lblVgr, BorderLayout.NORTH);
pnlVgrTab.add(vārdgrupas, BorderLayout.SOUTH);
pnlVgrTab.add(spanVgr);
spanVgr.getViewport().add(vārdgrupas, null);
pnlVgrĪpTab.add(lblVgrĪp, BorderLayout.NORTH);
pnlVgrĪpTab.add(vgrĪpašībuTabula, BorderLayout.SOUTH);
pnlVgrĪpTab.add(spanVgrĪp);
spanVgrĪp.getViewport().add(vgrĪpašībuTabula, null);
pnlGalTab.add(lblGal, BorderLayout.NORTH);
pnlGalTab.add(galotņuTabula, BorderLayout.SOUTH);
pnlGalTab.add(spanGal);
spanGal.getViewport().add(galotņuTabula, null);
pnlGalĪpTab.add(lblGalĪp, BorderLayout.NORTH);
pnlGalĪpTab.add(galotņuĪpašībuTabula, BorderLayout.SOUTH);
pnlGalĪpTab.add(spanGalĪp);
spanGalĪp.getViewport().add(galotņuĪpašībuTabula, null);
pnlLeksTab.add(lblLeks, BorderLayout.NORTH);
pnlLeksTab.add(leksēmuTabula, BorderLayout.SOUTH);
pnlLeksTab.add(spanLeks);
spanLeks.getViewport().add(leksēmuTabula, null);
pnlLeksĪpTab.add(lblLeksĪp, BorderLayout.NORTH);
pnlLeksĪpTab.add(leksēmuĪpašībuTabula, BorderLayout.SOUTH);
pnlLeksĪpTab.add(spanLeksĪp);
spanLeksĪp.getViewport().add(leksēmuĪpašībuTabula, null);
pnlGalTab.setPreferredSize(new Dimension(400, 400));
pnlGalotnes.add(pnlGalTab, BorderLayout.CENTER);
pnlGalĪpTab.setPreferredSize(new Dimension(400, 150));
pnlGalotnes.add(pnlGalĪpTab, BorderLayout.SOUTH);
pnlLeksTab.setPreferredSize(new Dimension(400, 400));
pnlLeksēmas.add(pnlLeksTab, BorderLayout.CENTER);
pnlLeksĪpTab.setPreferredSize(new Dimension(400, 150));
pnlLeksēmas.add(pnlLeksĪpTab, BorderLayout.SOUTH);
pnlVgrTab.setPreferredSize(new Dimension(400, 400));
pnlKreisais.add(pnlVgrTab, BorderLayout.CENTER);
pnlVgrĪpTab.setPreferredSize(new Dimension(400, 150));
pnlKreisais.add(pnlVgrĪpTab, BorderLayout.SOUTH);
centrs.add(pnlKreisais, BorderLayout.WEST);
centrs.add(pnlLeksēmas, BorderLayout.CENTER);
pārslēgt.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
changeTables();
}
});
aizvērt.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent arg0) {
aizvērtLogu();
}
});
leja.add(pārslēgt, BorderLayout.LINE_START);
leja.add(aizvērt, BorderLayout.LINE_END);
panelis.add(centrs, BorderLayout.CENTER);
panelis.add(leja, BorderLayout.SOUTH);
addWGroupPopupMenu();
addWGroupPropertiesPopupMenu();
addEndingPopupMenu();
addEngingPropertiesPopupMenu();
addLexemePopupMenu();
addLexemePropertiesPopupMenu();
this.pack();
}
/**
* @param editor the editor
* @param table where to put the action
*/
public static void registerAction(SwingScilabVariableEditor editor, JTable table) {
table.getActionMap().put(PRECISION, new SetPrecisionLongAction(editor, PRECISION));
table.getInputMap().put(ScilabKeyStroke.getKeyStroke(KEY), PRECISION);
}
private void init() throws Exception {
model = new MatchTableModel();
cbox = new JraComboBox();
cbox.setRenderer(
new BasicComboBoxRenderer() {
public Component getListCellRendererComponent(
JList l, Object val, int idx, boolean sel, boolean foc) {
if (sel && idx >= 0 && val instanceof MatchableCollection)
l.setToolTipText(((MatchableCollection) val).getToolTipText());
return super.getListCellRendererComponent(l, val, idx, sel, foc);
}
});
table =
new JTable(model) {
public void paintChildren(Graphics g) {
super.paintChildren(g);
paintSections(g);
}
public void changeSelection(int row, int col, boolean toggle, boolean extend) {
int scrow = row;
int oldrow = getSelectedRow();
int oldcol = getSelectedColumn();
int maxrow = model.getRowCount() - 2;
if (model.isRowHeader(row) && (toggle || extend)) return;
if (oldrow != -1 && model.isRowHeader(row)) {
if (oldrow < row) while (row < maxrow && model.isRowHeader(++row)) ;
else while (row > 0 && model.isRowHeader(--row)) ;
if (model.isRowHeader(row))
if (oldrow < row) while (row > 0 && model.isRowHeader(--row)) ;
else while (row < maxrow && model.isRowHeader(++row)) ;
if (model.isRowHeader(row)) row = oldrow;
}
if (scrow < 2) scrow = 0;
else if (scrow <= maxrow) scrow = row;
getSelectionModel().setSelectionInterval(row, row);
// super.changeSelection(row, col, false, false);
if (oldrow < 0) oldrow = row;
if ((toggle || extend) && (col == oldcol || row != oldrow)) {
if (!extend) selectOrToggle(row, true);
else {
int beg = (oldrow > row ? row : oldrow), end = oldrow + row - beg;
if (beg == end && extend) return;
for (int i = beg; i <= end; i++) selectOrToggle(i, toggle);
}
repaint();
}
if (getAutoscrolls()) {
Rectangle cellRect = getCellRect(scrow, 0, true);
if (cellRect != null) scrollRectToVisible(cellRect);
}
}
private void selectOrToggle(int row, boolean toggle) {
if (toggle) model.toggleRowSelected(row);
else model.setRowSelected(row, true);
}
};
table.setColumnSelectionAllowed(false);
table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
for (int i = 0; i < model.m_columns.length; i++)
table.getColumnModel().getColumn(i).setPreferredWidth(model.m_columns[i].m_width);
table
.getColumnModel()
.getColumn(1)
.setCellEditor(
new DefaultCellEditor(cbox) {
public Component getTableCellEditorComponent(
JTable t, Object v, boolean sel, int row, int col) {
cbox.setModel(new DefaultComboBoxModel(model.getMatchOptions(row)));
cbox.setToolTipText(
v instanceof MatchableCollection
? ((MatchableCollection) v).getToolTipText()
: null);
return super.getTableCellEditorComponent(t, v, sel, row, col);
}
});
table.setDefaultRenderer(
Object.class,
new DefaultTableCellRenderer() {
private javax.swing.border.Border emptyBorder =
BorderFactory.createEmptyBorder(0, 2, 0, 2);
private Color m = null;
private Color g = Color.green.darker().darker().darker();
private Color halfTone(Color cFrom, Color cTo, float factor) {
return new Color(
(int) (cFrom.getRed() * (1 - factor) + cTo.getRed() * factor),
(int) (cFrom.getGreen() * (1 - factor) + cTo.getGreen() * factor),
(int) (cFrom.getBlue() * (1 - factor) + cTo.getBlue() * factor));
}
public Component getTableCellRendererComponent(
JTable t, Object v, boolean sel, boolean foc, int row, int col) {
super.getTableCellRendererComponent(t, v, sel, false, row, col);
setOpaque(true);
setBorder(emptyBorder);
if (model.isRowSelected(row)) {
if (m == null) m = halfTone(Color.yellow, t.getBackground(), 0.75f);
super.setBackground(sel ? g : m);
} else super.setBackground(sel ? t.getSelectionBackground() : t.getBackground());
int rc = t.convertColumnIndexToModel(col);
if (rc == 2) setHorizontalAlignment(JLabel.TRAILING);
else {
setHorizontalAlignment(JLabel.LEADING);
if (rc == 0 || rc == 1) setToolTipText(model.getToolTip(row, col));
}
return this;
}
});
table.setRowHeight(21);
table.setPreferredScrollableViewportSize(
new Dimension(740, table.getPreferredScrollableViewportSize().height));
/* table.getActionMap().put("select-all", new AbstractAction() {
if (e.getKeyCode() == e.VK_A && e.getModifiers() == e.CTRL_MASK) {
for (int i = 0; i < model.getRowCount(); i++)
model.toggleRowSelected(i);
table.repaint();
e.consume();
}
});*/
table
.getActionMap()
.put(
"selectAll",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
if (table.isEditing()) table.removeEditor();
for (int i = 0; i < model.getRowCount(); i++) model.toggleRowSelected(i);
table.repaint();
}
});
table.addKeyListener(
new KeyAdapter() {
public void keyPressed(KeyEvent e) {
if (e.getKeyCode() == e.VK_ENTER && table.getSelectedRow() >= 0) {
model.toggleRowSelected(table.getSelectedRow());
table.repaint();
}
}
});
contents = new JPanel(new BorderLayout());
okp =
new OKpanel() {
public void jBOK_actionPerformed() {
OKPress();
}
public void jPrekid_actionPerformed() {
CancelPress();
}
};
JPanel pd = new JPanel(null);
pd.setLayout(new BoxLayout(pd, BoxLayout.X_AXIS));
JButton all = new JraButton();
all.setText("Oznaèi sve");
all.setIcon(raImages.getImageIcon(raImages.IMGALIGNJUSTIFY));
all.setPreferredSize(new Dimension(120, 25));
all.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < model.getRowCount(); i++) model.setRowSelected(i, true);
table.repaint();
}
});
okp.add(all, BorderLayout.WEST);
contents.add(new JraScrollPane(table));
contents.add(okp, BorderLayout.SOUTH);
okp.registerOKPanelKeys(table);
}
public ContentView(final ContentPane control) {
super(new GridLayout(1, 1));
this.control = control;
data = new JTable();
data.setModel(model = new ContentModel(getControl().getQueryModel() == null));
data.addMouseListener(popup = new ContentPopup(this));
data.addKeyListener(
new KeyAdapter() {
public void keyPressed(KeyEvent key) {
if (key.getKeyCode() == KeyEvent.VK_DOWN || key.getKeyCode() == KeyEvent.VK_PAGE_DOWN) {
if ((ContentView.this.data.getSelectedRow()
== ContentView.this.data.getRowCount() - 1)
&& !control.areAllRowsFetched()) {
int col = ContentView.this.data.getSelectedColumn();
int row = ContentView.this.data.getRowCount() - 1;
ContentView.this.data.scrollRectToVisible(
ContentView.this.data.getCellRect(row, col, true));
ContentView.this.data.setRowSelectionInterval(row + 1, row + 1);
ContentView.this.data.scrollRectToVisible(
ContentView.this.data.getCellRect(row + 1, col, true));
key.consume();
}
}
}
});
JScrollPane scroll = new JScrollPane(data);
scroll.getViewport().setBackground(UIManager.getDefaults().getColor("Table.background"));
add(scroll);
jsb = scroll.getVerticalScrollBar();
jsb.addAdjustmentListener(new ListenerScrollBar());
data.setRowSelectionAllowed(false);
data.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
data.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
data.setDefaultRenderer(Object.class, new InternalCellRenderer());
data.getTableHeader().addMouseListener(popup);
data.getTableHeader().setReorderingAllowed(false);
lines = new LineNumberView();
lines.addMouseListener(popup);
lines.setSelectionModel(data.getSelectionModel());
scroll.setRowHeaderView(lines);
JLabel cUL = new JLabel("#", JLabel.CENTER);
cUL.setBorder(UIManager.getBorder("TableHeader.cellBorder"));
cUL.setFont(UIManager.getFont("TableHeader.font"));
scroll.setCorner(JScrollPane.UPPER_LEFT_CORNER, cUL);
JLabel cLL = new JLabel();
cLL.setBorder(new CustomLineBorder(true, false, false, false));
scroll.setCorner(JScrollPane.LOWER_LEFT_CORNER, cLL);
data.getColumnModel().getSelectionModel().addListSelectionListener(this);
data.getActionMap().put("copy", ((JMenuItem) popup.getSubElementsAt(1)).getAction());
data.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_C, InputEvent.CTRL_MASK), "copy");
data.getActionMap().put("paste", ((JMenuItem) popup.getSubElementsAt(2)).getAction());
data.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_V, InputEvent.CTRL_MASK), "paste");
data.getActionMap().put("set-null", ((JMenuItem) popup.getSubElementsAt(3)).getAction());
data.getInputMap().put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0), "set-null");
MouseAdapter ma =
new MouseAdapter() {
public void mousePressed(MouseEvent me) {
ContentView.this.data.setColumnSelectionAllowed(
me.getSource() == ContentView.this.data.getTableHeader());
ContentView.this.data.setRowSelectionAllowed(me.getSource() == ContentView.this.lines);
}
};
data.getTableHeader().addMouseListener(ma);
data.addMouseListener(ma);
lines.addMouseListener(ma);
}
/**
* @param stylesPreferencesKey the preferences key with the list of active style sources
* (filenames and URLs)
* @param iconsPreferenceKey the preference key with the list of icon sources (can be null)
* @param availableStylesUrl the URL to the list of available style sources
*/
public StyleSourceEditor(
String stylesPreferencesKey, String iconsPreferenceKey, final String availableStylesUrl) {
DefaultListSelectionModel selectionModel = new DefaultListSelectionModel();
tblActiveStyles = new JTable(activeStylesModel = new ActiveStylesModel(selectionModel));
tblActiveStyles.putClientProperty("terminateEditOnFocusLost", true);
tblActiveStyles.setSelectionModel(selectionModel);
tblActiveStyles.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
tblActiveStyles.setTableHeader(null);
tblActiveStyles.getColumnModel().getColumn(0).setCellEditor(new FileOrUrlCellEditor());
tblActiveStyles.setRowHeight(20);
activeStylesModel.setActiveStyles(Main.pref.getCollection(stylesPreferencesKey, null));
selectionModel = new DefaultListSelectionModel();
lstAvailableStyles =
new JList(availableStylesModel = new AvailableStylesListModel(selectionModel));
lstAvailableStyles.setSelectionModel(selectionModel);
lstAvailableStyles.setCellRenderer(new StyleSourceCellRenderer());
// availableStylesModel.setStyleSources(reloadAvailableStyles(availableStylesUrl));
this.availableStylesUrl = availableStylesUrl;
this.pref = stylesPreferencesKey;
this.iconpref = iconsPreferenceKey;
JButton iconadd = null;
JButton iconedit = null;
JButton icondelete = null;
if (iconsPreferenceKey != null) {
selectionModel = new DefaultListSelectionModel();
tblIconPaths = new JTable(iconPathsModel = new IconPathTableModel(selectionModel));
tblIconPaths.setSelectionModel(selectionModel);
tblIconPaths.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
tblIconPaths.setTableHeader(null);
tblIconPaths.getColumnModel().getColumn(0).setCellEditor(new FileOrUrlCellEditor());
tblIconPaths.setRowHeight(20);
iconPathsModel.setIconPaths(Main.pref.getCollection(iconsPreferenceKey, null));
iconadd = new JButton(new NewIconPathAction());
EditIconPathAction editIconPathAction = new EditIconPathAction();
tblIconPaths.getSelectionModel().addListSelectionListener(editIconPathAction);
iconedit = new JButton(editIconPathAction);
RemoveIconPathAction removeIconPathAction = new RemoveIconPathAction();
tblIconPaths.getSelectionModel().addListSelectionListener(removeIconPathAction);
icondelete = new JButton(removeIconPathAction);
tblIconPaths
.getInputMap(JComponent.WHEN_FOCUSED)
.put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0), "delete");
tblIconPaths.getActionMap().put("delete", removeIconPathAction);
}
JButton add = new JButton(new NewActiveStyleAction());
EditActiveStyleAction editActiveStyleAction = new EditActiveStyleAction();
tblActiveStyles.getSelectionModel().addListSelectionListener(editActiveStyleAction);
JButton edit = new JButton(editActiveStyleAction);
RemoveActiveStylesAction removeActiveStylesAction = new RemoveActiveStylesAction();
tblActiveStyles.getSelectionModel().addListSelectionListener(removeActiveStylesAction);
tblActiveStyles
.getInputMap(JComponent.WHEN_FOCUSED)
.put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0), "delete");
tblActiveStyles.getActionMap().put("delete", removeActiveStylesAction);
JButton delete = new JButton(removeActiveStylesAction);
ActivateStylesAction activateStylesAction = new ActivateStylesAction();
lstAvailableStyles.addListSelectionListener(activateStylesAction);
JButton copy = new JButton(activateStylesAction);
JButton update = new JButton(new ReloadStylesAction(availableStylesUrl));
setBorder(BorderFactory.createEmptyBorder(0, 0, 0, 0));
setLayout(new GridBagLayout());
add(new JLabel(tr("Active styles")), GBC.eol().insets(5, 5, 5, 0));
JScrollPane sp;
add(sp = new JScrollPane(tblActiveStyles), GBC.eol().insets(5, 0, 5, 0).fill(GBC.BOTH));
sp.setColumnHeaderView(null);
JPanel buttonPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
add(buttonPanel, GBC.eol().insets(5, 0, 5, 5).fill(GBC.HORIZONTAL));
buttonPanel.add(add, GBC.std().insets(0, 5, 0, 0));
buttonPanel.add(edit, GBC.std().insets(5, 5, 5, 0));
buttonPanel.add(delete, GBC.std().insets(0, 5, 5, 0));
buttonPanel.add(copy, GBC.std().insets(0, 5, 5, 0));
add(
new JLabel(tr("Available styles (from {0})", availableStylesUrl)),
GBC.eol().insets(5, 5, 5, 0));
add(new JScrollPane(lstAvailableStyles), GBC.eol().insets(5, 0, 5, 0).fill(GBC.BOTH));
buttonPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
add(buttonPanel, GBC.eol().insets(5, 0, 5, 5).fill(GBC.HORIZONTAL));
buttonPanel.add(update, GBC.std().insets(0, 5, 0, 0));
if (tblIconPaths != null) {
add(new JLabel(tr("Icon paths")), GBC.eol().insets(5, -5, 5, 0));
add(sp = new JScrollPane(tblIconPaths), GBC.eol().insets(5, 0, 5, 0).fill(GBC.BOTH));
sp.setColumnHeaderView(null);
buttonPanel = new JPanel(new FlowLayout(FlowLayout.LEFT));
add(buttonPanel, GBC.eol().insets(5, 0, 5, 5).fill(GBC.HORIZONTAL));
buttonPanel.add(iconadd);
buttonPanel.add(iconedit);
buttonPanel.add(icondelete);
}
}
private void init(String title) {
diag = new JDialog(frame, title, false);
int activePreview = Globals.prefs.getInt(JabRefPreferences.ACTIVE_PREVIEW);
preview =
new PreviewPanel(
null,
new MetaData(),
activePreview == 0
? Globals.prefs.get(JabRefPreferences.PREVIEW_0)
: Globals.prefs.get(JabRefPreferences.PREVIEW_1));
sortedEntries =
new SortedList<BibtexEntry>(entries, new EntryComparator(false, true, "author"));
model = new EventTableModel<BibtexEntry>(sortedEntries, new EntryTableFormat());
entryTable = new JTable(model);
GeneralRenderer renderer = new GeneralRenderer(Color.white);
entryTable.setDefaultRenderer(JLabel.class, renderer);
entryTable.setDefaultRenderer(String.class, renderer);
setWidths();
TableComparatorChooser<BibtexEntry> tableSorter =
TableComparatorChooser.install(
entryTable, sortedEntries, AbstractTableComparatorChooser.MULTIPLE_COLUMN_KEYBOARD);
setupComparatorChooser(tableSorter);
JScrollPane sp = new JScrollPane(entryTable);
final EventSelectionModel<BibtexEntry> selectionModel =
new EventSelectionModel<BibtexEntry>(sortedEntries);
entryTable.setSelectionModel(selectionModel);
selectionModel.getSelected().addListEventListener(new EntrySelectionListener());
entryTable.addMouseListener(new TableClickListener());
contentPane.setTopComponent(sp);
contentPane.setBottomComponent(preview);
// Key bindings:
AbstractAction closeAction =
new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
diag.dispose();
}
};
ActionMap am = contentPane.getActionMap();
InputMap im = contentPane.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);
im.put(Globals.prefs.getKey("Close dialog"), "close");
am.put("close", closeAction);
entryTable
.getActionMap()
.put(
"copy",
new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
if (!selectionModel.getSelected().isEmpty()) {
BibtexEntry[] bes =
selectionModel
.getSelected()
.toArray(new BibtexEntry[selectionModel.getSelected().size()]);
TransferableBibtexEntry trbe = new TransferableBibtexEntry(bes);
// ! look at ClipBoardManager
Toolkit.getDefaultToolkit()
.getSystemClipboard()
.setContents(trbe, frame.basePanel());
frame.output(
Localization.lang("Copied")
+ ' '
+ (bes.length > 1
? bes.length + " " + Localization.lang("entries")
: "1 " + Localization.lang("entry") + '.'));
}
}
});
diag.addWindowListener(
new WindowAdapter() {
@Override
public void windowOpened(WindowEvent e) {
contentPane.setDividerLocation(0.5f);
}
@Override
public void windowClosing(WindowEvent event) {
Globals.prefs.putInt(JabRefPreferences.SEARCH_DIALOG_WIDTH, diag.getSize().width);
Globals.prefs.putInt(JabRefPreferences.SEARCH_DIALOG_HEIGHT, diag.getSize().height);
}
});
diag.getContentPane().add(contentPane, BorderLayout.CENTER);
// Remember and default to last size:
diag.setSize(
new Dimension(
Globals.prefs.getInt(JabRefPreferences.SEARCH_DIALOG_WIDTH),
Globals.prefs.getInt(JabRefPreferences.SEARCH_DIALOG_HEIGHT)));
diag.setLocationRelativeTo(frame);
}
public MemoryPanel(final Debugger debugger, boolean is64Bit) {
super();
this.debugger = debugger;
this.is64Bit = is64Bit;
if (is64Bit) {
addressSize = 8;
unmappedAddrString = "??????????????????";
} else {
addressSize = 4;
unmappedAddrString = "??????????";
}
setLayout(new BorderLayout());
setupScrollBar();
add(scrollBar, BorderLayout.EAST);
model =
new AbstractTableModel() {
public int getRowCount() {
return numVisibleRows;
}
public int getColumnCount() {
return 2;
}
public Object getValueAt(int row, int column) {
switch (column) {
case 0:
return bigIntToHexString(
startVal.add(new BigInteger(Integer.toString((row * addressSize)))));
case 1:
{
try {
Address addr =
bigIntToAddress(
startVal.add(new BigInteger(Integer.toString((row * addressSize)))));
if (addr != null) {
return addressToString(addr.getAddressAt(0));
}
return unmappedAddrString;
} catch (UnmappedAddressException e) {
return unmappedAddrString;
}
}
default:
throw new RuntimeException("Column " + column + " out of bounds");
}
}
public boolean isCellEditable(int row, int col) {
return false;
}
};
// View with JTable with no header
table = new JTable(model);
table.setTableHeader(null);
table.setShowGrid(false);
table.setIntercellSpacing(new Dimension(0, 0));
table.setCellSelectionEnabled(true);
table.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
table.setDragEnabled(true);
Font font = GraphicsUtilities.lookupFont("Courier");
if (font == null) {
throw new RuntimeException("Error looking up monospace font Courier");
}
table.setFont(font);
// Export proper data.
// We need to keep our own notion of the selection in order to
// properly export data, since the selection can go beyond the
// visible area on the screen (and since the table's model doesn't
// back all of those slots).
// Code thanks to Shannon.Hickey@sfbay
table.setTransferHandler(
new TransferHandler() {
protected Transferable createTransferable(JComponent c) {
JTable table = (JTable) c;
if (haveSelection()) {
StringBuffer buf = new StringBuffer();
int iDir = (getRowAnchor() < getRowLead() ? 1 : -1);
int jDir = (getColAnchor() < getColLead() ? 1 : -1);
for (int i = getRowAnchor(); i != getRowLead() + iDir; i += iDir) {
for (int j = getColAnchor(); j != getColLead() + jDir; j += jDir) {
Object val = model.getValueAt(i, j);
buf.append(val == null ? "" : val.toString());
if (j != getColLead()) {
buf.append("\t");
}
}
if (i != getRowLead()) {
buf.append("\n");
}
}
return new StringTransferable(buf.toString());
}
return null;
}
public int getSourceActions(JComponent c) {
return COPY;
}
public boolean importData(JComponent c, Transferable t) {
if (canImport(c, t.getTransferDataFlavors())) {
try {
String str = (String) t.getTransferData(DataFlavor.stringFlavor);
handleImport(c, str);
return true;
} catch (UnsupportedFlavorException ufe) {
} catch (IOException ioe) {
}
}
return false;
}
public boolean canImport(JComponent c, DataFlavor[] flavors) {
for (int i = 0; i < flavors.length; i++) {
if (DataFlavor.stringFlavor.equals(flavors[i])) {
return true;
}
}
return false;
}
private void handleImport(JComponent c, String str) {
// do whatever you want with the string here
try {
makeVisible(debugger.parseAddress(str));
clearSelection();
table.clearSelection();
} catch (NumberFormatException e) {
System.err.println("Unable to parse address \"" + str + "\"");
}
}
});
// Supporting keyboard scrolling
// See src/share/classes/javax/swing/plaf/metal/MetalLookAndFeel.java,
// search for Table.AncestorInputMap
// Actions to override:
// selectPreviousRow, selectNextRow,
// scrollUpChangeSelection, scrollDownChangeSelection,
// selectPreviousRowExtendSelection, selectNextRowExtendSelection,
// scrollDownExtendSelection, scrollUpExtendSelection (Shift-PgDn/PgUp)
ActionMap map = table.getActionMap();
// Up arrow
installActionWrapper(
map,
"selectPreviousRow",
new ActionWrapper() {
public void actionPerformed(ActionEvent e) {
beginUpdate();
clearSelection();
if (table.getSelectedRow() == 0) {
scrollBar.scrollUpOrLeft();
table.setRowSelectionInterval(0, 0);
} else {
super.actionPerformed(e);
}
maybeGrabSelection();
endUpdate();
}
});
// Down arrow
installActionWrapper(
map,
"selectNextRow",
new ActionWrapper() {
public void actionPerformed(ActionEvent e) {
beginUpdate();
clearSelection();
int row = table.getSelectedRow();
if (row >= numUsableRows) {
scrollBar.scrollDownOrRight();
table.setRowSelectionInterval(row, row);
} else {
super.actionPerformed(e);
}
maybeGrabSelection();
endUpdate();
}
});
// Page up
installActionWrapper(
map,
"scrollUpChangeSelection",
new ActionWrapper() {
public void actionPerformed(ActionEvent e) {
beginUpdate();
clearSelection();
int row = table.getSelectedRow();
scrollBar.pageUpOrLeft();
if (row >= 0) {
table.setRowSelectionInterval(row, row);
}
maybeGrabSelection();
endUpdate();
}
});
// Page down
installActionWrapper(
map,
"scrollDownChangeSelection",
new ActionWrapper() {
public void actionPerformed(ActionEvent e) {
beginUpdate();
clearSelection();
int row = table.getSelectedRow();
scrollBar.pageDownOrRight();
if (row >= 0) {
table.setRowSelectionInterval(row, row);
}
maybeGrabSelection();
endUpdate();
}
});
// Shift + Up arrow
installActionWrapper(
map,
"selectPreviousRowExtendSelection",
new ActionWrapper() {
public void actionPerformed(ActionEvent e) {
beginUpdate();
if (!haveAnchor()) {
setAnchorFromTable();
setLeadFromTable();
// setAnchor(table.getSelectedRow());
// setLead(table.getSelectedRow());
}
int newLead = getRowLead() - 1;
int newAnchor = getRowAnchor();
if (newLead < 0) {
scrollBar.scrollUpOrLeft();
++newLead;
++newAnchor;
}
setSelection(newAnchor, newLead, getColAnchor(), getColLead());
// printSelection();
endUpdate();
}
});
// Shift + Left arrow
installActionWrapper(
map,
"selectPreviousColumnExtendSelection",
new ActionWrapper() {
public void actionPerformed(ActionEvent e) {
beginUpdate();
if (!haveAnchor()) {
setAnchorFromTable();
setLeadFromTable();
}
int newLead = Math.max(0, getColLead() - 1);
setSelection(getRowAnchor(), getRowLead(), getColAnchor(), newLead);
// printSelection();
endUpdate();
}
});
// Shift + Down arrow
installActionWrapper(
map,
"selectNextRowExtendSelection",
new ActionWrapper() {
public void actionPerformed(ActionEvent e) {
beginUpdate();
if (!haveAnchor()) {
setAnchorFromTable();
setLeadFromTable();
// setAnchor(table.getSelectedRow());
// setLead(table.getSelectedRow());
}
int newLead = getRowLead() + 1;
int newAnchor = getRowAnchor();
if (newLead > numUsableRows) {
scrollBar.scrollDownOrRight();
--newLead;
--newAnchor;
}
setSelection(newAnchor, newLead, getColAnchor(), getColLead());
// printSelection();
endUpdate();
}
});
// Shift + Right arrow
installActionWrapper(
map,
"selectNextColumnExtendSelection",
new ActionWrapper() {
public void actionPerformed(ActionEvent e) {
beginUpdate();
if (!haveAnchor()) {
setAnchorFromTable();
setLeadFromTable();
}
int newLead = Math.min(model.getColumnCount() - 1, getColLead() + 1);
setSelection(getRowAnchor(), getRowLead(), getColAnchor(), newLead);
// printSelection();
endUpdate();
}
});
// Shift + Page up
installActionWrapper(
map,
"scrollUpExtendSelection",
new ActionWrapper() {
public void actionPerformed(ActionEvent e) {
beginUpdate();
if (!haveAnchor()) {
setAnchorFromTable();
setLeadFromTable();
// setAnchor(table.getSelectedRow());
// setLead(table.getSelectedRow());
}
int newLead = getRowLead() - numUsableRows;
int newAnchor = getRowAnchor();
if (newLead < 0) {
scrollBar.pageUpOrLeft();
newLead += numUsableRows;
newAnchor += numUsableRows;
}
setSelection(newAnchor, newLead, getColAnchor(), getColLead());
// printSelection();
endUpdate();
}
});
// Shift + Page down
installActionWrapper(
map,
"scrollDownExtendSelection",
new ActionWrapper() {
public void actionPerformed(ActionEvent e) {
beginUpdate();
if (!haveAnchor()) {
setAnchorFromTable();
setLeadFromTable();
// setAnchor(table.getSelectedRow());
// setLead(table.getSelectedRow());
}
int newLead = getRowLead() + numUsableRows;
int newAnchor = getRowAnchor();
if (newLead > numUsableRows) {
scrollBar.pageDownOrRight();
newLead -= numUsableRows;
newAnchor -= numUsableRows;
}
setSelection(newAnchor, newLead, getColAnchor(), getColLead());
// printSelection();
endUpdate();
}
});
// Clear our notion of selection upon mouse press
table.addMouseListener(
new MouseAdapter() {
public void mousePressed(MouseEvent e) {
if (shouldIgnore(e)) {
return;
}
// Make shift-clicking work properly
if (e.isShiftDown()) {
maybeGrabSelection();
return;
}
// System.err.println(" Clearing selection on mouse press");
clearSelection();
}
});
// Watch for mouse going out of bounds
table.addMouseMotionListener(
new MouseMotionAdapter() {
public void mouseDragged(MouseEvent e) {
if (shouldIgnore(e)) {
// System.err.println(" (Ignoring consumed mouse event)");
return;
}
// Look for drag events outside table and scroll if necessary
Point p = e.getPoint();
if (table.rowAtPoint(p) == -1) {
// See whether we are above or below the table
Rectangle rect = new Rectangle();
getBounds(rect);
beginUpdate();
if (p.y < rect.y) {
// System.err.println(" Scrolling up due to mouse event");
// Scroll up
scrollBar.scrollUpOrLeft();
setSelection(getRowAnchor(), 0, getColAnchor(), getColLead());
} else {
// System.err.println(" Scrolling down due to mouse event");
// Scroll down
scrollBar.scrollDownOrRight();
setSelection(getRowAnchor(), numUsableRows, getColAnchor(), getColLead());
}
// printSelection();
endUpdate();
} else {
maybeGrabSelection();
}
}
});
add(table, BorderLayout.CENTER);
// Make sure we recompute number of visible rows
addComponentListener(
new ComponentAdapter() {
public void componentResized(ComponentEvent e) {
recomputeNumVisibleRows();
constrain();
}
});
addHierarchyListener(
new HierarchyListener() {
public void hierarchyChanged(HierarchyEvent e) {
recomputeNumVisibleRows();
constrain();
}
});
updateFromScrollBar();
}
