private static void installActions(JTable table) {
InputMap inputMap = table.getInputMap(WHEN_FOCUSED);
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_END, 0), "selectLastRow");
inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_HOME, 0), "selectFirstRow");
inputMap.put(
KeyStroke.getKeyStroke(KeyEvent.VK_HOME, KeyEvent.SHIFT_DOWN_MASK),
"selectFirstRowExtendSelection");
inputMap.put(
KeyStroke.getKeyStroke(KeyEvent.VK_END, KeyEvent.SHIFT_DOWN_MASK),
"selectLastRowExtendSelection");
}
/**
* The Excel Adapter is constructed with a JTable on which it enables Copy-Paste and acts as a
* Clipboard listener.
*/
public ExcelAdapter(JTable myJTable) {
jTable1 = myJTable;
KeyStroke copy = KeyStroke.getKeyStroke(KeyEvent.VK_C, ActionEvent.CTRL_MASK, false);
// Identifying the copy KeyStroke user can modify this
// to copy on some other Key combination.
KeyStroke paste = KeyStroke.getKeyStroke(KeyEvent.VK_V, ActionEvent.CTRL_MASK, false);
// Identifying the Paste KeyStroke user can modify this
// to copy on some other Key combination.
jTable1.registerKeyboardAction(this, "Copy", copy, JComponent.WHEN_FOCUSED);
jTable1.registerKeyboardAction(this, "Paste", paste, JComponent.WHEN_FOCUSED);
system = Toolkit.getDefaultToolkit().getSystemClipboard();
}
@SuppressWarnings("HardCodedStringLiteral")
private boolean togglePopup(KeyEvent e) {
final KeyStroke stroke = KeyStroke.getKeyStroke(e.getKeyCode(), e.getModifiers());
final Object action = ((InputMap) UIManager.get("ComboBox.ancestorInputMap")).get(stroke);
if ("selectNext".equals(action)) {
if (!isPopupShowing()) {
return true;
} else {
return false;
}
} else if ("togglePopup".equals(action)) {
if (isPopupShowing()) {
closePopup();
} else {
suggestCompletion(true, true);
}
return true;
} else {
final Keymap active = KeymapManager.getInstance().getActiveKeymap();
final String[] ids = active.getActionIds(stroke);
if (ids.length > 0 && IdeActions.ACTION_CODE_COMPLETION.equals(ids[0])) {
suggestCompletion(true, true);
}
}
return false;
}
private void addShortcutBlinker() {
getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
.put(KeyStroke.getKeyStroke("ctrl B"), "Blink Function");
getActionMap()
.put(
"Blink Function",
new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
if (ACTIVE_FUNCTION == null) return;
setEnabled(false);
final Color3f oldColor = ACTIVE_FUNCTION.getColor();
ACTIVE_FUNCTION.setColor(Colors.WHITE);
Timer timer =
new Timer(
300,
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
ACTIVE_FUNCTION.setColor(oldColor);
setEnabled(true);
}
});
timer.setRepeats(false);
timer.start();
}
});
}
public void unbindKey(String keySequence) {
KeyStroke ks = KeyStroke.getKeyStroke(keySequence);
if (ks == null) {
throw new Error("Invalid key sequence \"" + keySequence + "\"");
}
textView.getKeymap().removeKeyStrokeBinding(ks);
}
/**
* 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);
}
/**
* 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);
}
public void bindKeyToCommand(String keySequence, LispExpr cmd) {
// see Java API for info on keySequence format
KeyStroke ks = KeyStroke.getKeyStroke(keySequence);
if (ks == null) {
throw new Error("Invalid key sequence \"" + keySequence + "\"");
}
textView.getKeymap().addActionForKeyStroke(ks, new KeyAction(cmd));
}
// Adds a new keybinding equal to the character provided and the default super key (ctrl/cmd)
private static void bind(int Character) {
frame
.getRootPane()
.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
.put(
KeyStroke.getKeyStroke(Character, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()),
"console");
}
private MergeDupLines() {
super(
UsageViewImpl.this,
UsageViewBundle.message("action.merge.same.line"),
IconLoader.getIcon("/toolbar/filterdups.png"));
setShortcutSet(
new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_F, InputEvent.CTRL_DOWN_MASK)));
}
@Override
protected void paintComponent(Graphics g) {
super.paintComponent(g);
if (myCurrentWindow == null || myCurrentWindow.getFiles().length == 0) {
g.setColor(UIUtil.isUnderDarcula() ? UIUtil.getBorderColor() : new Color(0, 0, 0, 50));
g.drawLine(0, 0, getWidth(), 0);
}
if (showEmptyText()) {
UIUtil.applyRenderingHints(g);
g.setColor(new JBColor(Gray._100, Gray._160));
g.setFont(UIUtil.getLabelFont().deriveFont(UIUtil.isUnderDarcula() ? 24f : 18f));
final UIUtil.TextPainter painter =
new UIUtil.TextPainter().withShadow(true).withLineSpacing(1.4f);
painter.appendLine("No files are open").underlined(new JBColor(Gray._150, Gray._100));
if (!isProjectViewVisible()) {
painter
.appendLine(
"Open Project View with "
+ KeymapUtil.getShortcutText(
new KeyboardShortcut(
KeyStroke.getKeyStroke((SystemInfo.isMac ? "meta" : "alt") + " 1"),
null)))
.smaller()
.withBullet();
}
painter
.appendLine("Open a file by name with " + getActionShortcutText("GotoFile"))
.smaller()
.withBullet()
.appendLine(
"Open Recent files with " + getActionShortcutText(IdeActions.ACTION_RECENT_FILES))
.smaller()
.withBullet()
.appendLine("Open Navigation Bar with " + getActionShortcutText("ShowNavBar"))
.smaller()
.withBullet()
.appendLine("Drag'n'Drop file(s) here from " + ShowFilePathAction.getFileManagerName())
.smaller()
.withBullet()
.draw(
g,
new PairFunction<Integer, Integer, Pair<Integer, Integer>>() {
@Override
public Pair<Integer, Integer> fun(Integer width, Integer height) {
final Dimension s = getSize();
return Pair.create((s.width - width) / 2, (s.height - height) / 2);
}
});
}
}
// ------------------------------------------------------------------
// from Java Swing 1.2 Orielly - Robert Eckstein
// ------------------------------------------------------------------
protected JTextComponent updateKeymapForWord(JTextComponent textComp) {
// create a new child keymap
Keymap map = JTextComponent.addKeymap("NslmMap", textComp.getKeymap());
// define the keystrokeds to be added
KeyStroke next = KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, InputEvent.CTRL_MASK, false);
// add the new mappings used DefaultEditorKit actions
map.addActionForKeyStroke(next, getAction(DefaultEditorKit.nextWordAction));
KeyStroke prev = KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, InputEvent.CTRL_MASK, false);
map.addActionForKeyStroke(prev, getAction(DefaultEditorKit.previousWordAction));
KeyStroke selNext =
KeyStroke.getKeyStroke(
KeyEvent.VK_RIGHT, InputEvent.CTRL_MASK | InputEvent.SHIFT_MASK, false);
map.addActionForKeyStroke(selNext, getAction(DefaultEditorKit.selectionNextWordAction));
KeyStroke selPrev =
KeyStroke.getKeyStroke(
KeyEvent.VK_LEFT, InputEvent.CTRL_MASK | InputEvent.SHIFT_MASK, false);
map.addActionForKeyStroke(selPrev, getAction(DefaultEditorKit.selectionPreviousWordAction));
KeyStroke find = KeyStroke.getKeyStroke(KeyEvent.VK_F, InputEvent.CTRL_MASK, false);
map.addActionForKeyStroke(find, getAction("find"));
KeyStroke findAgain = KeyStroke.getKeyStroke(KeyEvent.VK_G, InputEvent.CTRL_MASK, false);
map.addActionForKeyStroke(findAgain, getAction("findAgain"));
// set the keymap for the text component
textComp.setKeymap(map);
return (textComp);
} // end updateKeymapForWord
private static void installCutCopyPasteShortcuts(InputMap inputMap, boolean useSimpleActionKeys) {
String copyActionKey = useSimpleActionKeys ? "copy" : DefaultEditorKit.copyAction;
String pasteActionKey = useSimpleActionKeys ? "paste" : DefaultEditorKit.pasteAction;
String cutActionKey = useSimpleActionKeys ? "cut" : DefaultEditorKit.cutAction;
// Ctrl+Ins, Shift+Ins, Shift+Del
inputMap.put(
KeyStroke.getKeyStroke(
KeyEvent.VK_INSERT, InputEvent.CTRL_MASK | InputEvent.CTRL_DOWN_MASK),
copyActionKey);
inputMap.put(
KeyStroke.getKeyStroke(
KeyEvent.VK_INSERT, InputEvent.SHIFT_MASK | InputEvent.SHIFT_DOWN_MASK),
pasteActionKey);
inputMap.put(
KeyStroke.getKeyStroke(
KeyEvent.VK_DELETE, InputEvent.SHIFT_MASK | InputEvent.SHIFT_DOWN_MASK),
cutActionKey);
// Ctrl+C, Ctrl+V, Ctrl+X
inputMap.put(
KeyStroke.getKeyStroke(KeyEvent.VK_C, InputEvent.CTRL_MASK | InputEvent.CTRL_DOWN_MASK),
copyActionKey);
inputMap.put(
KeyStroke.getKeyStroke(KeyEvent.VK_V, InputEvent.CTRL_MASK | InputEvent.CTRL_DOWN_MASK),
pasteActionKey);
inputMap.put(
KeyStroke.getKeyStroke(KeyEvent.VK_X, InputEvent.CTRL_MASK | InputEvent.CTRL_DOWN_MASK),
DefaultEditorKit.cutAction);
}
// Private helper methods
private void createMenuBar() {
menuBar = new JMenuBar();
fileMenu = new JMenu("File");
miOpen = new JMenuItem("Open...");
miOpen.setAccelerator(
KeyStroke.getKeyStroke(java.awt.event.KeyEvent.VK_O, java.awt.Event.META_MASK));
fileMenu.add(miOpen).setEnabled(false);
miOpen.addActionListener(new MenuActionListener());
miSave = new JMenuItem("Save Selected...");
miSave.setAccelerator(
KeyStroke.getKeyStroke(java.awt.event.KeyEvent.VK_S, java.awt.Event.META_MASK));
fileMenu.add(miSave).setEnabled(false);
miSave.addActionListener(new MenuActionListener());
miSaveAll = new JMenuItem("Save All...");
fileMenu.add(miSaveAll).setEnabled(false);
miSaveAll.addActionListener(new MenuActionListener());
menuBar.add(fileMenu);
}
public ReferencePropertyWidget(boolean containedByListReferenceGUI) {
this.containedByListReferenceGUI = containedByListReferenceGUI;
// get Options
m_comboBox = new JComboBox();
m_comboBox.setEditable(false);
m_comboBox.setPreferredSize(new Dimension(300, 20));
// m_comboBox.setMinimumSize(new Dimension(260, 20));
m_comboBox.setMaximumSize(new Dimension(Short.MAX_VALUE, 20));
KeyStroke controlT = KeyStroke.getKeyStroke("control SPACE");
getTextField().getInputMap().put(controlT, controlT);
getTextField().getActionMap().put(controlT, new CodeCompleteAction());
ToolTipManager.sharedInstance().registerComponent(m_comboBox);
}
public TetrisComponent(Board board) {
this.board = board;
setPreferredSize(getPreferredSize());
SQUARE_COLOR.put(SquareType.I, Color.CYAN);
SQUARE_COLOR.put(SquareType.S, Color.RED);
SQUARE_COLOR.put(SquareType.Z, Color.GREEN);
SQUARE_COLOR.put(SquareType.T, Color.MAGENTA);
SQUARE_COLOR.put(SquareType.L, Color.ORANGE);
SQUARE_COLOR.put(SquareType.J, Color.BLUE);
SQUARE_COLOR.put(SquareType.O, Color.YELLOW);
SQUARE_COLOR.put(SquareType.EMPTY, Color.WHITE);
SQUARE_COLOR.put(SquareType.OUTSIDE, Color.BLACK);
getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
.put(KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0), "moveLeft");
getActionMap().put("moveLeft", moveLeft);
getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
.put(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0), "moveRight");
getActionMap().put("moveRight", moveRight);
getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
.put(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0), "rotate");
getActionMap().put("rotate", rotateBlock);
}
private void addShortcutDelete() {
getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW)
.put(KeyStroke.getKeyStroke("ctrl D"), "Delete Function");
getActionMap()
.put(
"Delete Function",
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
if (ACTIVE_FUNCTION == null) return;
deletePlot(ACTIVE_FUNCTION);
};
});
}
/**
* Returns a keystroke for the specified string.
*
* @param cmd command
* @return keystroke
*/
public static KeyStroke keyStroke(final GUICommand cmd) {
final Object sc = cmd.shortcuts();
if (sc == null) return null;
final String scut;
if (sc instanceof BaseXKeys[]) {
final BaseXKeys[] scs = (BaseXKeys[]) sc;
if (scs.length == 0) return null;
scut = scs[0].shortCut();
} else {
scut = Util.info(sc, META);
}
final KeyStroke ks = KeyStroke.getKeyStroke(scut);
if (ks == null) Util.errln("Could not assign shortcut: " + sc + " / " + scut);
return ks;
}
protected void fillToolbarActions(DefaultActionGroup group) {
final boolean alphabeticallySorted = PropertiesComponent.getInstance().isTrueValue(PROP_SORTED);
if (alphabeticallySorted) {
setSortComparator(new OrderComparator());
}
myAlphabeticallySorted = alphabeticallySorted;
group.add(mySortAction);
if (!supportsNestedContainers()) {
ShowContainersAction showContainersAction = getShowContainersAction();
showContainersAction.registerCustomShortcutSet(
new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_C, InputEvent.ALT_MASK)),
myTree);
setShowClasses(PropertiesComponent.getInstance().isTrueValue(PROP_SHOWCLASSES));
group.add(showContainersAction);
}
}
public void addDialogCloser(JComponent comp) {
AbstractAction closeAction =
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
setVisible(false);
}
};
// Then create a keystroke to use for it
KeyStroke ks = KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0);
// Finally, bind the keystroke and the action to *any* component
// within the dialog. Note the WHEN_IN_FOCUSED bit...this is what
// stops you having to do it for all components
comp.getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW).put(ks, "close");
comp.getActionMap().put("close", closeAction);
}
@Override
public void keyPressed(KeyEvent e) {
// Accept "copy" key strokes
KeyStroke ks = KeyStroke.getKeyStroke(e.getKeyCode(), e.getModifiers());
JComponent comp = (JComponent) e.getSource();
for (int i = 0; i < 3; i++) {
InputMap im = comp.getInputMap(i);
Object key = im.get(ks);
if (defaultEditorKitCopyActionName.equals(key)
|| transferHandlerCopyActionName.equals(key)) {
return;
}
}
// Accept JTable navigation key strokes
if (!tableNavigationKeys.contains(e.getKeyCode())) {
e.consume();
}
}
@Override
public void initUI() {
super.initUI();
if (Registry.is("tests.view.old.statistics.panel")) {
final KeyStroke shiftEnterKey =
KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, InputEvent.SHIFT_MASK);
SMRunnerUtil.registerAsAction(
shiftEnterKey,
"show-statistics-for-test-proxy",
new Runnable() {
public void run() {
showStatisticsForSelectedProxy();
}
},
myTreeView);
}
}
protected MemberChooser(
boolean allowEmptySelection,
boolean allowMultiSelection,
@NotNull Project project,
boolean isInsertOverrideVisible,
@Nullable JComponent headerPanel,
@Nullable JComponent[] optionControls) {
super(project, true);
myAllowEmptySelection = allowEmptySelection;
myAllowMultiSelection = allowMultiSelection;
myProject = project;
myIsInsertOverrideVisible = isInsertOverrideVisible;
myHeaderPanel = headerPanel;
myTree = createTree();
myOptionControls = optionControls;
mySortAction = new SortEmAction();
mySortAction.registerCustomShortcutSet(
new CustomShortcutSet(KeyStroke.getKeyStroke(KeyEvent.VK_A, InputEvent.ALT_MASK)), myTree);
}
public TextAreaCellEditor() {
super();
scroll = new JScrollPane(this);
scroll.setBorder(BorderFactory.createEmptyBorder());
// scroll.setViewportBorder(BorderFactory.createEmptyBorder());
setLineWrap(true);
setBorder(BorderFactory.createEmptyBorder(2, 4, 2, 4));
KeyStroke enter = KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, InputEvent.CTRL_DOWN_MASK);
getInputMap(JComponent.WHEN_FOCUSED).put(enter, KEY);
getActionMap()
.put(
KEY,
new AbstractAction() {
@Override
public void actionPerformed(ActionEvent e) {
stopCellEditing();
}
});
}
@SuppressWarnings({"HardCodedStringLiteral"})
public static void initInputMapDefaults(UIDefaults defaults) {
// Make ENTER work in JTrees
InputMap treeInputMap = (InputMap) defaults.get("Tree.focusInputMap");
if (treeInputMap != null) { // it's really possible. For example, GTK+ doesn't have such map
treeInputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0), "toggle");
}
// Cut/Copy/Paste in JTextAreas
InputMap textAreaInputMap = (InputMap) defaults.get("TextArea.focusInputMap");
if (textAreaInputMap
!= null) { // It really can be null, for example when LAF isn't properly initialized (Alloy
// license problem)
installCutCopyPasteShortcuts(textAreaInputMap, false);
}
// Cut/Copy/Paste in JTextFields
InputMap textFieldInputMap = (InputMap) defaults.get("TextField.focusInputMap");
if (textFieldInputMap
!= null) { // It really can be null, for example when LAF isn't properly initialized (Alloy
// license problem)
installCutCopyPasteShortcuts(textFieldInputMap, false);
}
// Cut/Copy/Paste in JPasswordField
InputMap passwordFieldInputMap = (InputMap) defaults.get("PasswordField.focusInputMap");
if (passwordFieldInputMap
!= null) { // It really can be null, for example when LAF isn't properly initialized (Alloy
// license problem)
installCutCopyPasteShortcuts(passwordFieldInputMap, false);
}
// Cut/Copy/Paste in JTables
InputMap tableInputMap = (InputMap) defaults.get("Table.ancestorInputMap");
if (tableInputMap
!= null) { // It really can be null, for example when LAF isn't properly initialized (Alloy
// license problem)
installCutCopyPasteShortcuts(tableInputMap, true);
}
}
public ClasspathPanelImpl(ModuleConfigurationState state) {
super(new BorderLayout());
myState = state;
myModel = new ClasspathTableModel(state, getStructureConfigurableContext());
myEntryTable =
new JBTable(myModel) {
@Override
protected TableRowSorter<TableModel> createRowSorter(TableModel model) {
return new DefaultColumnInfoBasedRowSorter(model) {
@Override
public void toggleSortOrder(int column) {
if (isSortable(column)) {
SortKey oldKey = ContainerUtil.getFirstItem(getSortKeys());
SortOrder oldOrder;
if (oldKey == null || oldKey.getColumn() != column) {
oldOrder = SortOrder.UNSORTED;
} else {
oldOrder = oldKey.getSortOrder();
}
setSortKeys(
Collections.singletonList(new SortKey(column, getNextSortOrder(oldOrder))));
}
}
};
}
};
myEntryTable.setShowGrid(false);
myEntryTable.setDragEnabled(false);
myEntryTable.setIntercellSpacing(new Dimension(0, 0));
myEntryTable.setDefaultRenderer(
ClasspathTableItem.class, new TableItemRenderer(getStructureConfigurableContext()));
myEntryTable.setDefaultRenderer(
Boolean.class, new ExportFlagRenderer(myEntryTable.getDefaultRenderer(Boolean.class)));
JComboBox scopeEditor =
new ComboBox(new EnumComboBoxModel<DependencyScope>(DependencyScope.class));
myEntryTable.setDefaultEditor(DependencyScope.class, new DefaultCellEditor(scopeEditor));
myEntryTable.setDefaultRenderer(
DependencyScope.class,
new ComboBoxTableRenderer<DependencyScope>(DependencyScope.values()) {
@Override
protected String getTextFor(@NotNull final DependencyScope value) {
return value.getDisplayName();
}
});
myEntryTable.setTransferHandler(
new TransferHandler() {
@Nullable
@Override
protected Transferable createTransferable(JComponent c) {
OrderEntry entry = getSelectedEntry();
if (entry == null) return null;
String text = entry.getPresentableName();
return new TextTransferable(text);
}
@Override
public int getSourceActions(JComponent c) {
return COPY;
}
});
myEntryTable
.getSelectionModel()
.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
new SpeedSearchBase<JBTable>(myEntryTable) {
@Override
public int getSelectedIndex() {
return myEntryTable.getSelectedRow();
}
@Override
protected int convertIndexToModel(int viewIndex) {
return myEntryTable.convertRowIndexToModel(viewIndex);
}
@Override
public Object[] getAllElements() {
final int count = myModel.getRowCount();
Object[] elements = new Object[count];
for (int idx = 0; idx < count; idx++) {
elements[idx] = myModel.getItem(idx);
}
return elements;
}
@Override
public String getElementText(Object element) {
return getCellAppearance(
(ClasspathTableItem<?>) element, getStructureConfigurableContext(), false)
.getText();
}
@Override
public void selectElement(Object element, String selectedText) {
final int count = myModel.getRowCount();
for (int row = 0; row < count; row++) {
if (element.equals(myModel.getItem(row))) {
final int viewRow = myEntryTable.convertRowIndexToView(row);
myEntryTable.getSelectionModel().setSelectionInterval(viewRow, viewRow);
TableUtil.scrollSelectionToVisible(myEntryTable);
break;
}
}
}
};
setFixedColumnWidth(ClasspathTableModel.EXPORT_COLUMN);
setFixedColumnWidth(ClasspathTableModel.SCOPE_COLUMN); // leave space for combobox border
myEntryTable.registerKeyboardAction(
new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
final int[] selectedRows = myEntryTable.getSelectedRows();
boolean currentlyMarked = true;
for (final int selectedRow : selectedRows) {
final ClasspathTableItem<?> item = getItemAt(selectedRow);
if (selectedRow < 0 || !item.isExportable()) {
return;
}
currentlyMarked &= item.isExported();
}
for (final int selectedRow : selectedRows) {
getItemAt(selectedRow).setExported(!currentlyMarked);
}
myModel.fireTableDataChanged();
TableUtil.selectRows(myEntryTable, selectedRows);
}
},
KeyStroke.getKeyStroke(KeyEvent.VK_SPACE, 0),
WHEN_FOCUSED);
myEditButton =
new AnActionButton(
ProjectBundle.message("module.classpath.button.edit"), null, IconUtil.getEditIcon()) {
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
doEdit();
}
@Override
public boolean isEnabled() {
ClasspathTableItem<?> selectedItem = getSelectedItem();
return selectedItem != null && selectedItem.isEditable();
}
@Override
public boolean isDumbAware() {
return true;
}
};
add(createTableWithButtons(), BorderLayout.CENTER);
if (myEntryTable.getRowCount() > 0) {
myEntryTable.getSelectionModel().setSelectionInterval(0, 0);
}
new DoubleClickListener() {
@Override
protected boolean onDoubleClick(MouseEvent e) {
navigate(true);
return true;
}
}.installOn(myEntryTable);
DefaultActionGroup actionGroup = new DefaultActionGroup();
final AnAction navigateAction =
new AnAction(ProjectBundle.message("classpath.panel.navigate.action.text")) {
@Override
public void actionPerformed(@NotNull AnActionEvent e) {
navigate(false);
}
@Override
public void update(@NotNull AnActionEvent e) {
final Presentation presentation = e.getPresentation();
presentation.setEnabled(false);
final OrderEntry entry = getSelectedEntry();
if (entry != null && entry.isValid()) {
if (!(entry instanceof ModuleSourceOrderEntry)) {
presentation.setEnabled(true);
}
}
}
};
navigateAction.registerCustomShortcutSet(
ActionManager.getInstance().getAction(IdeActions.ACTION_EDIT_SOURCE).getShortcutSet(),
myEntryTable);
actionGroup.add(myEditButton);
actionGroup.add(myRemoveButton);
actionGroup.add(navigateAction);
actionGroup.add(new InlineModuleDependencyAction(this));
actionGroup.add(new MyFindUsagesAction());
actionGroup.add(new AnalyzeDependencyAction());
addChangeLibraryLevelAction(actionGroup, LibraryTablesRegistrar.PROJECT_LEVEL);
addChangeLibraryLevelAction(actionGroup, LibraryTablesRegistrar.APPLICATION_LEVEL);
addChangeLibraryLevelAction(actionGroup, LibraryTableImplUtil.MODULE_LEVEL);
PopupHandler.installPopupHandler(
myEntryTable, actionGroup, ActionPlaces.UNKNOWN, ActionManager.getInstance());
}
/**
* This method is called when the focused component (and none of its ancestors) want the key
* event. This will look up the keystroke to see if any chidren (or subchildren) of the specified
* container want a crack at the event. If one of them wants it, then it will "DO-THE-RIGHT-THING"
*/
public boolean fireKeyboardAction(KeyEvent e, boolean pressed, Container topAncestor) {
if (e.isConsumed()) {
System.out.println("Acquired pre-used event!");
Thread.dumpStack();
}
// There may be two keystrokes associated with a low-level key event;
// in this case a keystroke made of an extended key code has a priority.
KeyStroke ks;
KeyStroke ksE = null;
if (e.getID() == KeyEvent.KEY_TYPED) {
ks = KeyStroke.getKeyStroke(e.getKeyChar());
} else {
if (e.getKeyCode() != e.getExtendedKeyCode()) {
ksE = KeyStroke.getKeyStroke(e.getExtendedKeyCode(), e.getModifiers(), !pressed);
}
ks = KeyStroke.getKeyStroke(e.getKeyCode(), e.getModifiers(), !pressed);
}
Hashtable keyMap = containerMap.get(topAncestor);
if (keyMap != null) { // this container isn't registered, so bail
Object tmp = null;
// extended code has priority
if (ksE != null) {
tmp = keyMap.get(ksE);
if (tmp != null) {
ks = ksE;
}
}
if (tmp == null) {
tmp = keyMap.get(ks);
}
if (tmp == null) {
// don't do anything
} else if (tmp instanceof JComponent) {
JComponent c = (JComponent) tmp;
if (c.isShowing() && c.isEnabled()) { // only give it out if enabled and visible
fireBinding(c, ks, e, pressed);
}
} else if (tmp instanceof Vector) { // more than one comp registered for this
Vector v = (Vector) tmp;
// There is no well defined order for WHEN_IN_FOCUSED_WINDOW
// bindings, but we give precedence to those bindings just
// added. This is done so that JMenus WHEN_IN_FOCUSED_WINDOW
// bindings are accessed before those of the JRootPane (they
// both have a WHEN_IN_FOCUSED_WINDOW binding for enter).
for (int counter = v.size() - 1; counter >= 0; counter--) {
JComponent c = (JComponent) v.elementAt(counter);
// System.out.println("Trying collision: " + c + " vector = "+ v.size());
if (c.isShowing() && c.isEnabled()) { // don't want to give these out
fireBinding(c, ks, e, pressed);
if (e.isConsumed()) return true;
}
}
} else {
System.out.println("Unexpected condition in fireKeyboardAction " + tmp);
// This means that tmp wasn't null, a JComponent, or a Vector. What is it?
Thread.dumpStack();
}
}
if (e.isConsumed()) {
return true;
}
// if no one else handled it, then give the menus a crack
// The're handled differently. The key is to let any JMenuBars
// process the event
if (keyMap != null) {
Vector v = (Vector) keyMap.get(JMenuBar.class);
if (v != null) {
Enumeration iter = v.elements();
while (iter.hasMoreElements()) {
JMenuBar mb = (JMenuBar) iter.nextElement();
if (mb.isShowing() && mb.isEnabled()) { // don't want to give these out
boolean extended = (ksE != null) && !ksE.equals(ks);
if (extended) {
fireBinding(mb, ksE, e, pressed);
}
if (!extended || !e.isConsumed()) {
fireBinding(mb, ks, e, pressed);
}
if (e.isConsumed()) {
return true;
}
}
}
}
}
return e.isConsumed();
}
public ReverseFlashCard() {
// basic init
setTitle("WayMemo -Reverse Flash Card Mode");
this.setSize(800, 600);
paneCenter = new JPanel(new GridLayout(7, 1));
add(ln, "North");
add(paneCenter, "Center");
add(b2, "West");
add(bReset, "South");
add(b1, "East");
paneCenter.add(l1);
paneCenter.add(l2);
paneCenter.add(l3);
paneCenter.add(l4);
paneCenter.add(l5);
paneCenter.add(b3);
paneCenter.add(pMark);
pMark.add(bMark);
pMark.add(bUnMark);
pMark.add(lt);
// text area init
Utility.initTextAreaView(l1);
Utility.initTextAreaView(l2);
Utility.initTextAreaView(l3);
Utility.initTextAreaView(l4);
Utility.initTextAreaView(l5);
// action
//
Action actionNext =
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
num++;
wordDisplay();
}
};
b1.getInputMap().put(KeyStroke.getKeyStroke("C"), "pressed");
b1.getActionMap().put("released", actionNext);
//
Action actionBack =
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
num--;
wordDisplay();
}
};
b2.getInputMap().put(KeyStroke.getKeyStroke("Z"), "pressed");
b2.getActionMap().put("released", actionBack);
//
Action actionShow =
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
l1.setText(dtr[num]);
l3.setText(d2[num]);
l4.setText(d3[num]);
l5.setText(d4[num]);
}
};
b3.getInputMap().put(KeyStroke.getKeyStroke("X"), "pressed");
b3.getActionMap().put("released", actionShow);
//
//
Action actionMark =
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
d1[num] = "[MARKED*]" + d1[num];
l2.setText(d1[num]);
}
};
bMark.getInputMap().put(KeyStroke.getKeyStroke("S"), "pressed");
bMark.getActionMap().put("released", actionMark);
//
//
//
Action actionUnmark =
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
d1[num] = od1[num];
l2.setText(d1[num]);
}
};
bUnMark.getInputMap().put(KeyStroke.getKeyStroke("F2"), "pressed");
bUnMark.getActionMap().put("released", actionUnmark);
//
//
Action actionReset =
new AbstractAction() {
public void actionPerformed(ActionEvent e) {
num = 0;
wordDisplay();
}
};
bReset.getInputMap().put(KeyStroke.getKeyStroke("r"), "pressed");
bReset.getActionMap().put("released", actionReset);
//
//
b1.setMnemonic(KeyEvent.VK_C);
b2.setMnemonic(KeyEvent.VK_Z);
b3.setMnemonic(KeyEvent.VK_X);
bMark.setMnemonic(KeyEvent.VK_S);
bUnMark.setMnemonic(KeyEvent.VK_D);
bReset.setMnemonic(KeyEvent.VK_R);
b1.addActionListener(actionNext);
b2.addActionListener(actionBack);
b3.addActionListener(actionShow);
bReset.addActionListener(actionReset);
bMark.addActionListener(actionMark);
bUnMark.addActionListener(actionUnmark);
//
//
try {
this.fileScan(new OpenFileDTR().getPathDTR());
} catch (IOException e) {
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (UnsupportedLookAndFeelException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
EditFrame(RopeFrame parent) {
super(parent);
// Implement a smarter way to set the initial frame position and size
setLocation(0, 0);
setSize(670, 705);
try {
jbInit();
} catch (Exception ex) {
ex.printStackTrace();
}
sourceArea.addCaretListener(this);
browseButton.addActionListener(this);
optionsButton.addActionListener(this);
assembleButton.addActionListener(this);
saveButton.addActionListener(this);
messageList.addMouseListener(
new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent event) {
highlightError(messageList.locationToIndex(event.getPoint()));
}
});
undoMgr = new CompoundUndoManager(sourceArea);
undoAction = undoMgr.getUndoAction();
redoAction = undoMgr.getRedoAction();
undoMgr.updateUndoAction = new UpdateUndoAction();
undoMgr.updateRedoAction = new UpdateRedoAction();
document = sourceArea.getDocument();
ActionMap am = sourceArea.getActionMap();
InputMap im = sourceArea.getInputMap(JComponent.WHEN_FOCUSED);
// Remove automatic key bindings because we want them controlled by menu items
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_Z, RopeHelper.modifierMaks), "none");
im.put(
KeyStroke.getKeyStroke(KeyEvent.VK_Z, RopeHelper.modifierMaks + InputEvent.SHIFT_MASK),
"none");
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_X, RopeHelper.modifierMaks), "none");
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_C, RopeHelper.modifierMaks), "none");
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_V, RopeHelper.modifierMaks), "none");
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_A, RopeHelper.modifierMaks), "none");
im.put(KeyStroke.getKeyStroke(KeyEvent.VK_L, RopeHelper.modifierMaks), "none");
// Set custom binding action for tab key
String action = "tabKeyAction";
im.put(KeyStroke.getKeyStroke("TAB"), action);
am.put(
action,
new AbstractAction() {
private static final long serialVersionUID = 1L;
@Override
public void actionPerformed(ActionEvent e) {
try {
int caretPos = sourceArea.getCaretPosition();
int lineNum = sourceArea.getLineOfOffset(caretPos);
int startLine = sourceArea.getLineStartOffset(lineNum);
int endLine = sourceArea.getLineEndOffset(lineNum);
int linePos = caretPos - startLine;
if (linePos >= 39 && linePos < 79) {
caretPos = startLine + linePos + 10 - ((linePos + 1) % 10);
} else if (linePos >= 20 && linePos <= 39) {
caretPos = startLine + 39;
} else if (linePos >= 15 && linePos <= 19) {
caretPos = startLine + 20;
} else if (linePos >= 5 && linePos <= 14) {
caretPos = startLine + 15;
} else {
caretPos = startLine + 5;
}
// If the line is shorter than the new position fo the caret add enough spaces...
if (caretPos > endLine) {
StringBuilder str = new StringBuilder();
int size = caretPos - endLine;
while (size-- >= 0) {
str.append(' ');
}
document.insertString(endLine - 1, str.toString(), null);
}
sourceArea.setCaretPosition(caretPos);
} catch (BadLocationException ex) {
ex.printStackTrace();
}
}
});
// Set custom binding action for return/enter key
String actionKey = "backspaceKeyAction";
im.put(KeyStroke.getKeyStroke("BACK_SPACE"), actionKey);
am.put(
actionKey,
new AbstractAction()
// How can I get the original action?
{
private static final long serialVersionUID = 1L;
@Override
public void actionPerformed(ActionEvent e) {
try {
int caretPos = sourceArea.getCaretPosition();
int lineNum = sourceArea.getLineOfOffset(caretPos);
int startLine = sourceArea.getLineStartOffset(lineNum);
int endLine = sourceArea.getLineEndOffset(lineNum);
int linePos = caretPos - startLine;
if (linePos == 15) {
int endPos = 5;
int charPos = linePos;
for (; charPos > endPos; charPos--) {
char ch = sourceArea.getText().charAt((startLine + charPos) - 1);
if (!Character.isWhitespace(ch)) {
break;
}
}
sourceArea.setCaretPosition(startLine + charPos);
} else {
int startSel = sourceArea.getSelectionStart();
int endSel = sourceArea.getSelectionEnd();
if (startSel == endSel) {
startSel = caretPos - 1;
endSel = caretPos;
}
StringBuilder sb = new StringBuilder(sourceArea.getText());
sb.replace(startSel, endSel, "");
sourceArea.setText(sb.toString());
sourceArea.setCaretPosition(startSel);
}
} catch (BadLocationException ex) {
ex.printStackTrace();
}
}
});
// Set custom binding action for return/enter key
action = "enterKeyAction";
im.put(KeyStroke.getKeyStroke("ENTER"), action);
am.put(
action,
new AbstractAction() {
private static final long serialVersionUID = 1L;
@Override
public void actionPerformed(ActionEvent e) {
try {
int caretPos = sourceArea.getCaretPosition();
int lineNum = sourceArea.getLineOfOffset(caretPos);
int startLine = sourceArea.getLineStartOffset(lineNum);
int linePos = caretPos - startLine;
if (linePos >= 5) {
document.insertString(caretPos, "\n ", null);
} else {
document.insertString(caretPos, "\n", null);
}
} catch (BadLocationException ex) {
ex.printStackTrace();
}
}
});
document.addDocumentListener(
new DocumentListener() {
@Override
public void insertUpdate(DocumentEvent e) {
setSourceChanged(true);
}
@Override
public void removeUpdate(DocumentEvent e) {
setSourceChanged(true);
}
@Override
public void changedUpdate(DocumentEvent e) {
setSourceChanged(true);
}
});
}
public static void makeMenuBar(JFrame frame, final AirspaceBuilderController controller) {
JMenuBar menuBar = new JMenuBar();
final JCheckBoxMenuItem resizeNewShapesItem;
final JCheckBoxMenuItem enableEditItem;
JMenu menu = new JMenu("File");
{
JMenuItem item = new JMenuItem("Open...");
item.setAccelerator(
KeyStroke.getKeyStroke(
KeyEvent.VK_O, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
item.setActionCommand(OPEN);
item.addActionListener(controller);
menu.add(item);
item = new JMenuItem("Open URL...");
item.setActionCommand(OPEN_URL);
item.addActionListener(controller);
menu.add(item);
item = new JMenuItem("Save...");
item.setAccelerator(
KeyStroke.getKeyStroke(
KeyEvent.VK_S, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
item.setActionCommand(SAVE);
item.addActionListener(controller);
menu.add(item);
menu.addSeparator();
item = new JMenuItem("Load Demo Shapes");
item.setActionCommand(OPEN_DEMO_AIRSPACES);
item.addActionListener(controller);
menu.add(item);
}
menuBar.add(menu);
menu = new JMenu("Shape");
{
JMenu subMenu = new JMenu("New");
for (final AirspaceFactory factory : defaultAirspaceFactories) {
JMenuItem item = new JMenuItem(factory.toString());
item.addActionListener(
new ActionListener() {
public void actionPerformed(ActionEvent e) {
controller.createNewEntry(factory);
}
});
subMenu.add(item);
}
menu.add(subMenu);
resizeNewShapesItem = new JCheckBoxMenuItem("Fit new shapes to viewport");
resizeNewShapesItem.setActionCommand(SIZE_NEW_SHAPES_TO_VIEWPORT);
resizeNewShapesItem.addActionListener(controller);
resizeNewShapesItem.setState(controller.isResizeNewShapesToViewport());
menu.add(resizeNewShapesItem);
enableEditItem = new JCheckBoxMenuItem("Enable shape editing");
enableEditItem.setActionCommand(ENABLE_EDIT);
enableEditItem.addActionListener(controller);
enableEditItem.setState(controller.isEnableEdit());
menu.add(enableEditItem);
}
menuBar.add(menu);
menu = new JMenu("Selection");
{
JMenuItem item = new JMenuItem("Deselect");
item.setAccelerator(
KeyStroke.getKeyStroke(
KeyEvent.VK_D, Toolkit.getDefaultToolkit().getMenuShortcutKeyMask()));
item.setActionCommand(CLEAR_SELECTION);
item.addActionListener(controller);
menu.add(item);
item = new JMenuItem("Delete");
item.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0));
item.setActionCommand(REMOVE_SELECTED);
item.addActionListener(controller);
menu.add(item);
}
menuBar.add(menu);
frame.setJMenuBar(menuBar);
controller.addPropertyChangeListener(
new PropertyChangeListener() {
public void propertyChange(PropertyChangeEvent e) {
if (SIZE_NEW_SHAPES_TO_VIEWPORT.equals((e.getPropertyName()))) {
resizeNewShapesItem.setSelected(controller.isResizeNewShapesToViewport());
} else if (ENABLE_EDIT.equals(e.getPropertyName())) {
enableEditItem.setSelected(controller.isEnableEdit());
}
}
});
}