Java Code Examples for java.awt.event.KeyListener

public final KeyListener getKeyListener() {
    return new KeyAdapter() {
        @Override
        public void keyTyped(final KeyEvent keyEvent) {
            super.keyTyped(keyEvent);
            if (keyEvent.getKeyChar() == KeyEvent.VK_ENTER) {
                DefaultMutableTreeNode selectedNode = (DefaultMutableTreeNode)
                        windowObjects.getjTree().getLastSelectedPathComponent();
                if (selectedNode.isLeaf()) {
                    final CodeInfo codeInfo = (CodeInfo) selectedNode.getUserObject();
                    try {
                        showEditor(codeInfo);
                    } catch (Exception e) {
                        KBNotification.getInstance().error(e);
                        e.printStackTrace();
                    }
                }
            }
        }
    };
}
 

private boolean processComponentKeyListeners(KeyEvent keyEvent) {

		Component focusOwner = focusProvider.getFocusOwner();
		if (focusOwner == null) {
			return false;
		}

		KeyListener[] keyListeners = focusOwner.getKeyListeners();
		for (KeyListener listener : keyListeners) {
			int id = keyEvent.getID();
			switch (id) {
				case KeyEvent.KEY_TYPED:
					listener.keyTyped(keyEvent);
					break;
				case KeyEvent.KEY_PRESSED:
					listener.keyPressed(keyEvent);
					break;
				case KeyEvent.KEY_RELEASED:
					listener.keyReleased(keyEvent);
					break;
			}
		}

		return keyEvent.isConsumed();
	}
 

private void triggerAutoLookup(String text) throws Exception {

		KeyListener listener = (KeyListener) getInstanceField("autoLookupListener", symbolTable);

		BiConsumer<Component, KeyEvent> consumer = (c, e) -> {
			if (e.getID() != KeyEvent.KEY_PRESSED) {
				return;
			}
			runSwing(() -> listener.keyPressed(e));
		};

		// use the version of triggerText that allows us to consume the event directly, bypassing
		// the focus system
		triggerText(symbolTable, text, consumer);
		waitForNotBusy(symbolTable);
	}
 

/**
 * Removes components that is only used when in game.
 */
public void removeInGameComponents() {
    // remove listeners, they will be added when launching the new game...
    KeyListener[] keyListeners = getKeyListeners();
    for (KeyListener keyListener : keyListeners) {
        removeKeyListener(keyListener);
    }

    MouseListener[] mouseListeners = getMouseListeners();
    for (MouseListener mouseListener : mouseListeners) {
        removeMouseListener(mouseListener);
    }

    MouseMotionListener[] mouseMotionListeners = getMouseMotionListeners();
    for (MouseMotionListener mouseMotionListener : mouseMotionListeners) {
        removeMouseMotionListener(mouseMotionListener);
    }

    for (Component c : getComponents()) {
        removeFromCanvas(c);
    }
}
 

private static void addFocusArrowListener(JComponent jc) {
    /* Check to see if someone already added this kind of listener:
     */
    KeyListener[] listeners = jc.getKeyListeners();
    for (KeyListener listener : listeners) {
        if (listener instanceof FocusArrowListener) {
            return;
        }
    }
    //Add our own:
    jc.addKeyListener(new FocusArrowListener());
}
 

private static void addFocusArrowListener(JComponent jc) {
	/**
	 * Check to see if someone already added this kind of listener:
	 */
	KeyListener[] listeners = jc.getKeyListeners();
	for (int a = 0; a < listeners.length; a++) {
		if (listeners[a] instanceof FocusArrowListener)
			return;
	}
	// Add our own:
	jc.addKeyListener(new FocusArrowListener());
}
 

public DNDTree(final Project project, final DefaultMutableTreeNode root, final Color background) {
	this.project = project;
	this.background = background;
	setAutoscrolls(true);
	setModel(new DefaultTreeModel(root));
	setRootVisible(true); 
	setShowsRootHandles(false);//to show the root icon
	getSelectionModel().setSelectionMode(TreeSelectionModel.SINGLE_TREE_SELECTION); //set single selection for the Tree
	setEditable(true);
	//DNDTree.expandAllNodes(this, root);
	// so weird this instance below does not need to be kept anywhere: where is Java storing it?
	dtth = new DefaultTreeTransferHandler(project, this, DnDConstants.ACTION_COPY_OR_MOVE);
	//
	this.setScrollsOnExpand(true);
	KeyListener[] kls = getKeyListeners();
	if (null != kls) for (KeyListener kl : kls) { Utils.log2("removing kl: " + kl); removeKeyListener(kl); }
	//resetKeyboardActions(); // removing the KeyListeners is not enough!
	//setActionMap(new ActionMap()); // an empty one -- none of these two lines has any effect towards stopping the key events.
	this.addKeyListener(this);

	if (null != background) {
		final DefaultTreeCellRenderer renderer = createNodeRenderer();
		renderer.setBackground(background);
		renderer.setBackgroundNonSelectionColor(background);
		// I hate swing, I really do. And java has no closures, no macros, and reflection is nearly as verbose as the code below!
		SwingUtilities.invokeLater(new Runnable() { public void run() {
			DNDTree.this.setCellRenderer(renderer);
		}});
		SwingUtilities.invokeLater(new Runnable() { public void run() {
			DNDTree.this.setBackground(background);
		}});
	}
}
 

public void reinitialize() {
	// Here we set in_ to the MessageConsole's textComponent,
	// for fetching from elsewhere. I wonder if it should be
	// instead set to the error panel? That's passed in the
	// above constructor. But that ends up here, bound anyhow
	// to the error panel.
	
	if (null != in_) {
		textComponent.removeKeyListener(in_);
		try {
			in_.close();
		} catch (IOException ioex) {
			// who cares?
		}
		in_ =  null;
	}

	in_ = new InputStreamClass.DocInputStream(textComponent, this);
	
	// We want input to come here. See also setFocusable.
	// This ends binding to the errorPanel:
	//
	//	... errorPanel = new javax.swing.JTextPane();
	
       textComponent.setFocusable(true);
       
       // Make sure there are no other listeners
       final EventListener[] els = textComponent.getListeners(EventListener.class);
       for (final EventListener listener : els) {
       	if (listener instanceof KeyListener) {
       		textComponent.removeKeyListener((KeyListener)listener);
       	}
       }
       
       textComponent.addKeyListener(in_);
}
 

/**
 * Maps {@code Component.removeKeyListener(KeyListener)} through queue
 */
public void removeKeyListener(final KeyListener keyListener) {
    runMapping(new MapVoidAction("removeKeyListener") {
        @Override
        public void map() {
            getSource().removeKeyListener(keyListener);
        }
    });
}
 

public KeyEditor(KeyListener listener) {
    initComponents();
    passwd1.setText("");
    passwd2.setText("");
    passwd1.addKeyListener(listener);
    passwd2.addKeyListener(listener);
    alias.addKeyListener(listener);
    firstAndLastName.addKeyListener(listener);
    organizationUnit.addKeyListener(listener);
    organization.addKeyListener(listener);
    city.addKeyListener(listener);
    stateOrProvince.addKeyListener(listener);
    countryCode.addKeyListener(listener);
}
 

/**
 * Invoked when a key has been typed. See the class description for {@link java.awt.event.KeyEvent} for a definition
 * of a key typed event.
 */
public void keyTyped( final KeyEvent e ) {
  final KeyListener[] keyListeners = listenerList.getListeners( KeyListener.class );
  for ( int i = 0; i < keyListeners.length; i++ ) {
    final KeyListener keyListener = keyListeners[ i ];
    keyListener.keyTyped( e );
  }
}
 

/**
 * Adds the specified key listener to receive key events from this
 * component. If l is null, no exception is thrown and no action is
 * performed.
 *
 * @param l the key listener.
 */
public void addKeyListener(KeyListener l) {
    if (frame != null) {
        frame.addKeyListener(l);
    } else {
        component.addKeyListener(l);
    }
}
 

/**
 * This method will remove the existing keylisteners from the component 'c',
 * tells 'firstKeyListener' to call those key listeners if it has not dealt
 * with the key, and then sets 'firstKeyListener' as the key listener for
 * 'c'
 */
public static void setAsFirstKeyListener(final Component c, final QueueJumpingKeyListener firstKeyListener) {
	final KeyListener[] oldKeyListeners = c.getKeyListeners();
	for (final KeyListener kl : oldKeyListeners) {
		c.removeKeyListener(kl);
	}
	firstKeyListener.addOtherKeyListeners(oldKeyListeners);
	c.addKeyListener(firstKeyListener);
}
 

@CalledOnlyBy(AmidstThread.EDT)
public KeyListener createKeyListener() {
	return new KeyAdapter() {
		@CalledOnlyBy(AmidstThread.EDT)
		@Override
		public void keyPressed(KeyEvent e) {
			if (!isLoading()) {
				doKeyPressed(e.getKeyCode());
			}
		}
	};
}
 

@Override
public void keyReleased(final KeyEvent e) {
	for (final KeyListener kl : listeners) {
		if (e.isConsumed())
			break;
		kl.keyReleased(e);
	}
}
 

/**
 * Invoked when a key has been pressed.
 * See the class description for {@link KeyEvent} for a definition of
 * a key pressed event.
 */
public void keyPressed(KeyEvent e) {
    for (KeyListener child : children) {
        child.keyPressed(e);
        if (e.isConsumed()) {
            return;
        }
    }

    if (acceptingEvents) {
        _keyPressed(e);
    }
}
 

/**
 * Invoked when a key has been typed.
 * See the class description for {@link KeyEvent} for a definition of
 * a key typed event.
 */
public void keyTyped(KeyEvent e) {
    for (KeyListener child : children) {
        child.keyTyped(e);
        if (e.isConsumed()) {
            return;
        }
    }

    if (acceptingEvents) {
        _keyTyped(e);
    }
}
 

/**
 * Clear all key listeners. NOTE: this method will also remove the default listener.
 */
public void clearKeyListeners() {
    KeyListener[] listeners = frame.getKeyListeners();
    for (KeyListener listener : listeners) {
        removeKeyListener(listener);
    }
}
 

private void setupSearch() {
    // Remove the default key listeners
    KeyListener[] keyListeners = getListeners(KeyListener.class);

    for (int i = 0; i < keyListeners.length; i++) {
        removeKeyListener(keyListeners[i]);
    }

    // Add new key listeners
    addKeyListener(
        new KeyAdapter() {
        @Override
            public void keyPressed(KeyEvent e) {
                int modifiers = e.getModifiers();
                int keyCode = e.getKeyCode();

                if (((modifiers > 0) && (modifiers != KeyEvent.SHIFT_MASK)) || e.isActionKey()) {
                    return;
                }

                char c = e.getKeyChar();

                if (!Character.isISOControl(c) && (keyCode != KeyEvent.VK_SHIFT)) {
                    searchTextField.setText(String.valueOf(c));
                    displaySearchField();
                }
            }
        }
    );

    // Create a the "multi-event" listener for the text field. Instead of
    // adding separate instances of each needed listener, we're using a
    // class which implements them all. This approach is used in order
    // to avoid the creation of 4 instances which takes some time
    SearchFieldListener searchFieldListener = new SearchFieldListener();
    searchTextField.addKeyListener(searchFieldListener);
    searchTextField.addFocusListener(searchFieldListener);
    searchTextField.getDocument().addDocumentListener(searchFieldListener);
}
 

/**
 * Maps {@code Component.addKeyListener(KeyListener)} through queue
 */
public void addKeyListener(final KeyListener keyListener) {
    runMapping(new MapVoidAction("addKeyListener") {
        @Override
        public void map() {
            getSource().addKeyListener(keyListener);
        }
    });
}
 

@Override
protected void processKeyEvent(KeyEvent e) {
    KeyStroke ks = KeyStroke.getKeyStrokeForEvent(e);
    if (enter.equals(ks)) {
        // Prevent JComponent.processKeyBindings() to be called (it is called from
        // JComponent.processKeyEvent() ), notify only registered key listeners
        int id = e.getID();
        for (KeyListener keyListener : getKeyListeners()) {
            switch(id) {
              case KeyEvent.KEY_TYPED:
                  keyListener.keyTyped(e);
                  break;
              case KeyEvent.KEY_PRESSED:
                  keyListener.keyPressed(e);
                  break;
              case KeyEvent.KEY_RELEASED:
                  keyListener.keyReleased(e);
                  break;
            }
        }
        if (!e.isConsumed() && id == KeyEvent.KEY_PRESSED) {
            synchronized(listeners) {
                List<CellEditorListener> list = new ArrayList<CellEditorListener>(listeners);
                for (CellEditorListener listener : list) {
                    listener.editingStopped(new ChangeEvent(this));
                }
            }
        }
        e.consume();
    } else {
        super.processKeyEvent(e);
    }
}
 

/**
 * Creates a new numeric key entry filter.
 *
 * @param field        The {@link JTextField} to filter.
 * @param allowDecimal Pass in {@code true} to allow floating point.
 * @param allowSign    Pass in {@code true} to allow sign characters.
 * @param allowGroup   Pass in {@code true} to allow group characters.
 * @param maxDigits    The maximum number of digits (not necessarily characters) the field can
 *                     have.
 */
public NumberFilter(JTextField field, boolean allowDecimal, boolean allowSign, boolean allowGroup, int maxDigits) {
    mField = field;
    mAllowDecimal = allowDecimal;
    mAllowSign = allowSign;
    mAllowGroup = allowGroup;
    mMaxDigits = maxDigits;
    for (KeyListener listener : mField.getKeyListeners()) {
        if (listener instanceof NumberFilter) {
            mField.removeKeyListener(listener);
        }
    }
    mField.addKeyListener(this);
}
 

private KeyListener customKeyListener() {
    final KeyAdapter adapter = new KeyAdapter() {

        @Override
        public void keyTyped(KeyEvent e) {

            String modifiedQuery = "(?i)" + searchField.getText();
            tableRowShorter.setRowFilter(RowFilter.regexFilter(modifiedQuery));

            super.keyTyped(e);
        }

    };
    return adapter;
}
 

/**
 * Invoked when a key has been released.
 * See the class description for {@link KeyEvent} for a definition of
 * a key released event.
 */
public void keyReleased(KeyEvent e) {
    for (KeyListener child : children) {
        child.keyReleased(e);
        if (e.isConsumed()) {
            return;
        }
    }

    if (acceptingEvents) {
        _keyReleased(e);
    }
}
 

private KeyListener getKeyListener() {
	KeyAdapter listener = new KeyAdapter() {
		@Override
		public void keyTyped(KeyEvent e) {
			char c = e.getKeyChar();
			if(Character.isLetter(c) && !e.isAltDown()) {
				e.consume();
			}
		}
	};
	return listener;
}
 

public static JTextField createTextField(String text, KeyListener listener, boolean numbers)
{
    JTextField field = new JTextField(text);
    field.setMinimumSize(textPrefSize);
    if(text.length() == 0)
        field.setPreferredSize(textPrefSize);
    if(listener != null)
        field.addKeyListener(listener);
    if(numbers)
        field.setDocument(new NumberDocument());
    return field;
}
 

public static ActionCallback installKeyboardDelegation(final JComponent focusedComponent, final JList delegateTo) {
  final KeyListener keyListener = new KeyAdapter() {
    @Override
    public void keyPressed(KeyEvent e) {
      final int code = e.getKeyCode();
      final int modifiers = e.getModifiers();
      switch (code) {
        case KeyEvent.VK_UP:
          ScrollingUtil.moveUp(delegateTo, modifiers);
          break;
        case KeyEvent.VK_DOWN:
          ScrollingUtil.moveDown(delegateTo, modifiers);
          break;
        case KeyEvent.VK_HOME:
          ScrollingUtil.moveHome(delegateTo);
          break;
        case KeyEvent.VK_END:
          ScrollingUtil.moveEnd(delegateTo);
          break;
        case KeyEvent.VK_PAGE_UP:
          ScrollingUtil.movePageUp(delegateTo);
          break;
        case KeyEvent.VK_PAGE_DOWN:
          ScrollingUtil.movePageDown(delegateTo);
          break;
      }
    }
  };

  focusedComponent.addKeyListener(keyListener);

  final ActionCallback callback = new ActionCallback();
  callback.doWhenProcessed(() -> focusedComponent.removeKeyListener(keyListener));
  return callback;
}
 

public void removeKeyListener(KeyListener listener) {
    remove(listener);
}
 

public void add(KeyListener listener) {
}
 

public void remove(KeyListener listener) {
}