Java KeyEvent.VK_TAB属性代码示例

@Override
public void keyPressed(KeyEvent e) {            
    shouldHide = false;
    switch (e.getKeyCode()) {
        case KeyEvent.VK_ENTER:
            shouldHide = true;
            break;
        case KeyEvent.VK_ESCAPE:
            shouldHide = true;
            break;
        case KeyEvent.VK_TAB:
            setSelectedItem(getSearchString());
            shouldHide = true;
        default:
            break;
    }
}
 

private static boolean usableKeyOnMac(int key, int mask) {
    //All permutations fail for Q except ctrl
    if (key == KeyEvent.VK_Q) {
        return false;
    }

    boolean isMeta = ((mask & KeyEvent.META_MASK) != 0) || ((mask & KeyEvent.CTRL_DOWN_MASK) != 0);

    boolean isAlt = ((mask & KeyEvent.ALT_MASK) != 0) || ((mask & KeyEvent.ALT_DOWN_MASK) != 0);

    boolean isOnlyMeta = isMeta && ((mask & ~(KeyEvent.META_DOWN_MASK | KeyEvent.META_MASK)) == 0);

    //Mac OS consumes keys Command+ these keys - the app will never see
    //them, so CTRL should not be remapped for these
    if (isOnlyMeta) {
        return (key != KeyEvent.VK_H) && (key != KeyEvent.VK_SPACE) && (key != KeyEvent.VK_TAB);
    }
    if ((key == KeyEvent.VK_D) && isMeta && isAlt) {
        return false;
    }
    if (key == KeyEvent.VK_SPACE && isMeta && ((mask & KeyEvent.CTRL_MASK) != 0)) {
        // http://lists.apple.com/archives/java-dev/2010/Aug/msg00002.html
        return false;
    }
    return true;
}
 

@Override
public void processKeyEvent(KeyEvent e) {
    //Manually hook in the bindings for tab - does not seem to get called
    //automatically
    if (isEditing() && ((e.getKeyCode() == KeyEvent.VK_DOWN) || (e.getKeyCode() == KeyEvent.VK_UP))) {
        return; //XXX
    }

    //Bypass standard tab and escape handling, and use our registered
    //actions instead
    if (
        !isEditing() ||
            (((e.getKeyCode() != KeyEvent.VK_TAB) && (e.getKeyCode() != KeyEvent.VK_ESCAPE)) ||
            ((e.getModifiers() & KeyEvent.CTRL_MASK) != 0))
    ) {
        super.processKeyEvent(e);
    } else {
        processKeyBinding(
            KeyStroke.getKeyStroke(e.getKeyCode(), e.getModifiersEx(), e.getID() == KeyEvent.KEY_RELEASED), e,
            JComponent.WHEN_FOCUSED, e.getID() == KeyEvent.KEY_PRESSED
        );
    }
}
 

void passToSearchField(KeyEvent e) {
    if (! isQuickSearchAllowed()) {
        return;
    }

    //Don't do anything for normal navigation keys
    if (
        (e.getKeyCode() == KeyEvent.VK_TAB) || (e.getKeyCode() == KeyEvent.VK_ENTER) ||
            (((e.getKeyCode() == KeyEvent.VK_UP) || (e.getKeyCode() == KeyEvent.VK_DOWN)) &&
            ((searchField == null) || !searchField.isShowing()))
    ) {
        return;
    }

    if (getRowCount() == 0) {
        return;
    }

    if ((searchField == null) || !searchField.isShowing()) {
        showSearchField();
        searchField.setText(String.valueOf(e.getKeyChar()));
    }
}
 

@Override
public void keyPressed(KeyEvent e) {
    int keyCode = e.getKeyCode();
    if (keyCode == KeyEvent.VK_ESCAPE) {
        removeSearchField();
        ETable.this.requestFocus();
    } else if (keyCode == KeyEvent.VK_UP) {
        currentSelectionIndex--;
        displaySearchResult();
        // Stop processing the event here. Otherwise it's dispatched
        // to the table too (which scrolls)
        e.consume();
    } else if (keyCode == KeyEvent.VK_DOWN) {
        currentSelectionIndex++;
        displaySearchResult();
        // Stop processing the event here. Otherwise it's dispatched
        // to the table too (which scrolls)
        e.consume();
    } else if (keyCode == KeyEvent.VK_TAB) {
        if (maxPrefix != null) {
            searchTextField.setText(maxPrefix);
        }
        e.consume();
    } else if (keyCode == KeyEvent.VK_ENTER) {
        removeSearchField();
        
        // TODO: do something on hitting enter???
        e.consume();
        ETable.this.requestFocus();
    }
}
 

@Override
public void keyPressed(KeyEvent ke) {
	
	int keyCode = ke.getKeyCode();
	Object keSource = ke.getSource();
	JTextField jTextField = (JTextField) keSource;;
	int caretPos = jTextField.getCaretPosition();
	int textLength = jTextField.getText().length();
	
	if(keyCode == KeyEvent.VK_ESCAPE){
		// Due to a java bug, the callback method is not called automatically when pressing escape.
		cancelCellEditing();
	} else if(keyCode == KeyEvent.VK_ENTER || keyCode == KeyEvent.VK_TAB){
		// Remember which key was used to confirm editing
		confirmationKey = keyCode;
	} else if(keyCode==KeyEvent.VK_RIGHT && caretPos==textLength){
		confirmationKey = keyCode;
		stopCellEditing();
	} else if(keyCode==KeyEvent.VK_LEFT && caretPos==0){
		confirmationKey = keyCode;
		stopCellEditing();
	}
}
 

@Override
public void keyPressed(KeyEvent e) {
	if(e.getKeyCode() == KeyEvent.VK_ENTER || e.getKeyCode() == KeyEvent.VK_TAB){
		try {
			((JSpinner)editorComponent).commitEdit();
			
		} catch (ParseException e1) {
			DefaultEditor de = (DefaultEditor) ((JSpinner)editorComponent).getEditor();
			String text = de.getTextField().getText();
			if(text.matches("^\\d+(\\.\\d*)?")){
				((JSpinner)editorComponent).setValue(Float.parseFloat(text));
			}else{
				System.err.println("Invalid input - ignoring");
			}
		}
	}
	super.keyPressed(e);
}
 

@Override
public void keyTyped(KeyEvent ke) {       
    if(ke.getKeyCode() == KeyEvent.VK_LEFT ||
            ke.getKeyCode() == KeyEvent.VK_RIGHT ||
            ke.getKeyCode() == KeyEvent.VK_UP ||
            ke.getKeyCode() == KeyEvent.VK_DOWN) {
        return;
    }
    
    if(pane.getSelectedText() != null ||  
            ke.getKeyChar()== KeyEvent.VK_DELETE ||
            ke.getKeyChar()== KeyEvent.VK_BACK_SPACE ||
            (ke.isShiftDown() && ke.getKeyChar() == KeyEvent.VK_TAB)) {            
        try {
            prevText = pane.getStyledDocument().getText(0, pane.getStyledDocument().getLength());
        } catch (BadLocationException ex) {
            Logger.getLogger(SaveTextBeforeRemove.class.getName()).log(Level.SEVERE, null, ex);
        }
    }        
}
 

@Test
public void testCreateNewfileCEditor() throws InterruptedException {
    CElectionDescriptionEditor electionDescriptionEditor = helper.getCEditorOfCurrentInstace();
    ElectionDescription electionDescription = electionDescriptionEditor.getElectionDescription();
    Assert.assertEquals(electionDescription.getInputType().getInputID(),
            ElectionTypeContainer.ElectionInputTypeIds.SINGLE_CHOICE);

    electionDescriptionEditor.setVisible(true);
    helper.clickMenuItemInCEditor(0,0,waittime);

    int[] keys = {
            KeyEvent.VK_DOWN, KeyEvent.VK_DOWN, KeyEvent.VK_ENTER, //choose new election input
            KeyEvent.VK_TAB, //switch to name field
            KeyEvent.VK_N, //type new name
            KeyEvent.VK_ENTER //clicks apply
    };

    helper.performKeystrokes(keys, 50);
    electionDescription = electionDescriptionEditor.getElectionDescription();
    Assert.assertEquals(electionDescription.getInputType().getInputID(),
            ElectionTypeContainer.ElectionInputTypeIds.PREFERENCE);

    helper.endInstance();
}
 

@Override
public void keyPressed(KeyEvent e) {
    int keyCode = e.getKeyCode();

    if (keyCode == KeyEvent.VK_ESCAPE) {
        removeSearchField();
        NbList.this.requestFocus();
    } else if (keyCode == KeyEvent.VK_UP) {
        currentSelectionIndex--;
        displaySearchResult();

        // Stop processing the event here. Otherwise it's dispatched
        // to the tree too (which scrolls)
        e.consume();
    } else if (keyCode == KeyEvent.VK_DOWN) {
        currentSelectionIndex++;
        displaySearchResult();

        // Stop processing the event here. Otherwise it's dispatched
        // to the tree too (which scrolls)
        e.consume();
    } else if (keyCode == KeyEvent.VK_TAB) {
        if (maxPrefix != null) {
            searchTextField.setText(maxPrefix);
        }

        e.consume();
    } else if (keyCode == KeyEvent.VK_ENTER) {
        removeSearchField();
        NbList.this.requestFocus();
        NbList.this.dispatchEvent(e);
    }
}
 

public static String getTextForKeyChar(char keyChar) {
    int keycode;
    switch (keyChar) {
    case ' ':
        keycode = KeyEvent.VK_SPACE;
        break;
    case '\b':
        keycode = KeyEvent.VK_BACK_SPACE;
        break;
    case '\t':
        keycode = KeyEvent.VK_TAB;
        break;
    case '\n':
        keycode = KeyEvent.VK_ENTER;
        break;
    case '\u0018':
        keycode = KeyEvent.VK_CANCEL;
        break;
    case '\u001b':
        keycode = KeyEvent.VK_ESCAPE;
        break;
    case '\u007f':
        keycode = KeyEvent.VK_DELETE;
        break;
    default:
        return "" + keyChar;
    }
    return (String) keyCodes.get(Integer.valueOf(keycode));
}
 

private boolean isCompletionKey (int keyCode, JTextField textField) {
    if (keyCode == KeyEvent.VK_ENTER || keyCode == KeyEvent.VK_TAB) {
        return true;
    }
    if (keyCode == KeyEvent.VK_RIGHT && 
            (textField.getCaretPosition() >= (textField.getDocument().getLength() - 1))) {
        return true;
    }
    
    return false;
}
 

@Override
public void keyPressed(KeyEvent evt) {
    showPopupCompletion = true;
    int keyCode = evt.getKeyCode();
    // #105801: completionPopup might not be ready when updateCompletions not called (empty text field)
    if (completionPopup != null && !completionPopup.isVisible()) {
        if (keyCode == KeyEvent.VK_ENTER) {
            File file = getFileChooser().getFileSystemView().createFileObject(filenameTextField.getText());
            if(file.exists() && file.isDirectory()) {
                setSelected(new File[] {file});
                fileChooser.approveSelection();
                if (file.getParentFile() == null) {
                    // this will hopefully prevent popup to take inappropriate action
                    evt.consume();
                }
            }
        }
        
        if ((keyCode == KeyEvent.VK_TAB || keyCode == KeyEvent.VK_DOWN) ||
            (keyCode == KeyEvent.VK_RIGHT && 
            (filenameTextField.getCaretPosition() >= (filenameTextField.getDocument().getLength() - 1)))) {
            updateCompletions();
        }
        
    }
    
    if(filenameTextField.isFocusOwner() && 
            (completionPopup == null || !completionPopup.isVisible()) &&
            keyCode == KeyEvent.VK_ESCAPE) {
        fileChooser.cancelSelection();
    }
}
 

private void jTextVMOptionsKeyPressed(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_jTextVMOptionsKeyPressed
    if (evt.getKeyCode() == KeyEvent.VK_ENTER) {
        evt.consume();
    }
    if (evt.getKeyCode() == KeyEvent.VK_TAB) {
        if (evt.getModifiers() > 0) {
            jTextVMOptions.transferFocusBackward();
        } else {
            jTextVMOptions.transferFocus();
        }
        evt.consume();
    }
}
 

@Override
public boolean stopCellEditing() {
	table.setRowHeight(row, originalRowHeight);
	if(confirmationKey == KeyEvent.VK_ENTER && row < table.getRowCount()){
		table.changeSelection(row+1, column, false, false);
	}else if(confirmationKey == KeyEvent.VK_TAB && column< table.getColumnCount()){
		table.changeSelection(row, column+1, false, false);
	}else{
		table.changeSelection(row, column, false, false);
	}
	return super.stopCellEditing();
}