Java KeyEvent.VK_DOWN属性代码示例

@Override
public NavigationKey[] getKeys(ComponentOperator oper) {
    boolean multiString = oper instanceof TextAreaOperator;
    NavigationKey[] result = new NavigationKey[multiString ? 4 : 2];
    result[0] = new UpKey(KeyEvent.VK_LEFT, 0);
    result[1] = new DownKey(KeyEvent.VK_RIGHT, 0);
    ((UpKey) result[0]).setDownKey((DownKey) result[1]);
    ((DownKey) result[1]).setUpKey((UpKey) result[0]);
    if (multiString) {
        result[2] = new UpKey(KeyEvent.VK_UP, 0);
        result[3] = new DownKey(KeyEvent.VK_DOWN, 0);
        ((UpKey) result[2]).setDownKey((DownKey) result[3]);
        ((DownKey) result[3]).setUpKey((UpKey) result[2]);
    }
    return result;
}
 

@Override
public void keyPressed(KeyEvent e) {
    int step = e.isControlDown() ? 50 : e.isAltDown() ? 1 : 5;
    switch (e.getKeyCode()) {
        case KeyEvent.VK_LEFT:
            setLocation(getX() - step, getY());
            break;
        case KeyEvent.VK_RIGHT:
            setLocation(getX() + step, getY());
            break;
        case KeyEvent.VK_UP:
            setLocation(getX(), getY() - step);
            break;
        case KeyEvent.VK_DOWN:
            setLocation(getX(), getY() + step);
            break;
        case KeyEvent.VK_ESCAPE:
            exitAction.actionPerformed(null);
    }
}
 

public void keyPressed(KeyEvent e) {
	int i = targetList.getSelectedIndex();
	switch (e.getKeyCode()) {
	case KeyEvent.VK_UP:
		i = targetList.getSelectedIndex() - 1;
		if (i < 0) {
			i = 0;
		}
		targetList.setSelectedIndex(i);
		break;
	case KeyEvent.VK_DOWN:
		int listSize = targetList.getModel().getSize();
		i = targetList.getSelectedIndex() + 1;
		if (i >= listSize) {
			i = listSize - 1;
		}
		targetList.setSelectedIndex(i);
		break;
	default:
		break;
	}
}
 

/**
 * execute
 * called by an element and use the code of the last key pressed to use the specific method to move the element
 * */
@Override
public void execute() {
    switch (this.lastKey){
        case KeyEvent.VK_UP:
            this.element.goUp();
            break;
        case KeyEvent.VK_DOWN:
            this.element.goDown();
            break;
        case KeyEvent.VK_LEFT:
            this.element.goLeft();
            break;
        case KeyEvent.VK_RIGHT:
            this.element.goRight();
            break;
        default:
            this.element.goRest();
    }
}
 

@Override
public void selectItem(ComponentOperator oper, int index) {
    ListOperator loper = (ListOperator) oper;
    if (loper.isMultipleMode()) {
        super.selectItem(loper, index);
    }
    DriverManager.getFocusDriver(oper).giveFocus(oper);
    KeyDriver kDriver = DriverManager.getKeyDriver(oper);
    int current = loper.getSelectedIndex();
    int diff = 0;
    int key = 0;
    if (index > current) {
        diff = index - current;
        key = KeyEvent.VK_DOWN;
    } else {
        diff = current - index;
        key = KeyEvent.VK_UP;
    }
    Timeout pushTime = oper.getTimeouts().create("ComponentOperator.PushKeyTimeout");
    for (int i = 0; i < diff; i++) {
        kDriver.pushKey(oper, key, 0, pushTime);
    }
    kDriver.pushKey(oper, KeyEvent.VK_ENTER, 0, pushTime);
}
 

private Button getButton(KeyEvent e) {
    switch (e.getKeyCode()) {
        case KeyEvent.VK_LEFT:
            return Button.LEFT;

        case KeyEvent.VK_RIGHT:
            return Button.RIGHT;

        case KeyEvent.VK_UP:
            return Button.UP;

        case KeyEvent.VK_DOWN:
            return Button.DOWN;

        case KeyEvent.VK_Z:
            return Button.A;

        case KeyEvent.VK_X:
            return Button.B;

        case KeyEvent.VK_ENTER:
            return Button.START;

        case KeyEvent.VK_BACK_SPACE:
            return Button.SELECT;
    }
    return null;
}
 

protected void onInputFieldKeyPressedEvent(KeyEvent e)
{
	if (this.inputHistory.isEmpty()) return;

	if (e.getKeyCode() == KeyEvent.VK_UP)
	{
		this.inputHistoryIndex++;

		if (this.inputHistoryIndex >= this.inputHistory.size())
		{
			this.inputHistoryIndex = this.inputHistory.size() - 1;
		}

		this.inputField.setText(this.inputHistory.get(this.inputHistoryIndex));
	}
	else if (e.getKeyCode() == KeyEvent.VK_DOWN)
	{
		this.inputHistoryIndex--;

		if (this.inputHistoryIndex < 0)
		{
			this.inputField.setText("");
			this.inputHistoryIndex = -1;
		}
		else
		{
			this.inputField.setText(this.inputHistory.get(this.inputHistoryIndex));
		}
	}
}
 

private void regBiasTextFieldKeyPressed(java.awt.event.KeyEvent evt) {//GEN-FIRST:event_regBiasTextFieldKeyPressed
        // key pressed in text field
        //        System.out.println("keyPressed evt "+evt);
        //        System.out.println("value field key pressed");
        int code = evt.getKeyCode();
        if (code == KeyEvent.VK_UP) {
            pot.setRegBitValue(pot.getRegBitValue() + 1);
            endEdit();
        } else if (code == KeyEvent.VK_DOWN) {
            startEdit();
            pot.setRegBitValue(pot.getRegBitValue() - 1);
            endEdit();
        }
        pot.updateBitValue();
}
 

public void keyPressed(KeyEvent e) {

      /*
       * Pass key onto window scroller if no region selected
       * or control key not used.
       */
      if (selectedRegions.isEmpty() || !e.isControlDown())
        return;

      int dx = 0, dy = 0, delta = 1;

      if (e.isShiftDown()) {
        delta = 5;
      }

      switch (e.getKeyCode()) {
        case KeyEvent.VK_UP:
          dy = -delta;
          break;
        case KeyEvent.VK_DOWN:
          dy = delta;
          break;
        case KeyEvent.VK_LEFT:
          dx = -delta;
          break;
        case KeyEvent.VK_RIGHT:
          dx = delta;
          break;
        default :
          return;
      }

      for (Region r : selectedRegions) {
        r.move(dx, dy, view);
      }

      view.repaint();
      e.consume();
    }
 

public static void keySet(int i, boolean b) {
	if(i == KeyEvent.VK_UP) keyState[UP] = b;
	else if(i == KeyEvent.VK_LEFT) keyState[LEFT] = b;
	else if(i == KeyEvent.VK_DOWN) keyState[DOWN] = b;
	else if(i == KeyEvent.VK_RIGHT) keyState[RIGHT] = b;
	else if(i == KeyEvent.VK_W) keyState[BUTTON1] = b;
	else if(i == KeyEvent.VK_E) keyState[BUTTON2] = b;
	else if(i == KeyEvent.VK_R) keyState[BUTTON3] = b;
	else if(i == KeyEvent.VK_F) keyState[BUTTON4] = b;
	else if(i == KeyEvent.VK_ENTER) keyState[ENTER] = b;
	else if(i == KeyEvent.VK_ESCAPE) keyState[ESCAPE] = b;
}
 

private void bufferCurrentTFKeyPressed(final java.awt.event.KeyEvent evt) {// GEN-FIRST:event_bufferCurrentTFKeyPressed
    // key pressed in text field
    // System.out.println("keyPressed evt "+evt);
    // System.out.println("value field key pressed");
    final int code = evt.getKeyCode();
    if (code == KeyEvent.VK_UP) {
        pot.setBufferBitValue(pot.getBufferBitValue() + 1);
        endEdit();
    } else if (code == KeyEvent.VK_DOWN) {
        startEdit();
        pot.setBufferBitValue(pot.getBufferBitValue() - 1);
        endEdit();
    }
    pot.updateBitValue();
}
 

@Override
public void keyPressed(KeyEvent e) {
	// TODO Auto-generated method stub
	if(e.getKeyCode() == KeyEvent.VK_DELETE || e.getKeyCode() == KeyEvent.VK_BACK_SPACE ) {
		if(isEditable()){
			if((PrincipalWindow.interpreter.getText().substring(PrincipalWindow.interpreter.getText().length()-2).equals("/>")))
			e.consume();}
		else
			e.consume();
	}
	
	if(e.getKeyCode() == KeyEvent.VK_ENTER && !isEditable() ) 
		e.consume();
	
	if(e.getKeyCode() == KeyEvent.VK_UP && isEditable() ){
		e.consume();
		if(!(Math.abs(Interpreter.historyCounter)>=Interpreter.historyQuery.size()))
			Interpreter.historyCounter --;
		else
			Interpreter.historyCounter = -Interpreter.historyQuery.size();

		displayHistory();
	}
	if(e.getKeyCode() == KeyEvent.VK_DOWN && isEditable() ){
		e.consume();
		if(Interpreter.historyCounter < 0)
			Interpreter.historyCounter ++;
		else
			Interpreter.historyCounter = 0;
		
		displayHistory();
	}	
}
 

@Override
public void keyPressed(KeyEvent e) {
    if (diagramaAtual != null) {
        switch (e.getKeyCode()) {
            case KeyEvent.VK_LEFT:
            case KeyEvent.VK_RIGHT:
            case KeyEvent.VK_UP:
            case KeyEvent.VK_DOWN:
            case KeyEvent.VK_ESCAPE:
            case KeyEvent.VK_ENTER:
                diagramaAtual.ProcesseTeclas(e);
                break;
            case KeyEvent.VK_DELETE:
                if (diagramaAtual != null) {
                    diagramaAtual.deleteSelecao();
                    e.consume();
                }
                break;
            case KeyEvent.VK_TAB:
                if (e.isControlDown()) {
                    if (e.isShiftDown()) {
                        if (diagramaAtual.SelecioneAnterior()) {
                            e.consume();
                        }
                    } else if (diagramaAtual.SelecioneProximo()) {
                        e.consume();
                    }
                } else {
                    transferFocus();
                }
                break;
        }
    }
}
 

@Override
public void keyPressed(final KeyEvent e) {
	final boolean up = (e.getKeyCode() == KeyEvent.VK_UP);
	final boolean down = (e.getKeyCode() == KeyEvent.VK_DOWN);

	if (up || down) {
		incValueAndUpdateGUI(up ? 1 : -1, (JTextField) e.getSource());
	}
}
 

private void showWindow() {
    List<DVThread> threads = ThreadsHistoryAction.getThreads();
    int threadsCount = threads.size();
    if (threadsCount < 1) {
        Toolkit.getDefaultToolkit().beep();
        return;
    }
    int triggerKey = KeyEvent.VK_DOWN;
    int releaseKey = KeyEvent.VK_ENTER;
    KeyboardPopupSwitcher.selectItem(
            ThreadsHistoryAction.createSwitcherItems(threads),
            releaseKey, triggerKey, true, true);
}