Java KeyboardFocusManager.getCurrentKeyboardFocusManager方法代码示例

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
@Override
public void actionPerformed(ActionEvent e) {
    int selIndexBefore = getSelectedIndex();
    defaultAction.actionPerformed( e );
    int selIndexCurrent = getSelectedIndex();
    if( selIndexBefore != selIndexCurrent )
        return;
    
    if( focusNext && 0 == selIndexCurrent && getModel().getSize() > 1 && getModel().getSize() > getColumnCount() )
        return;
    
    KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
    Container container = kfm.getCurrentFocusCycleRoot();
    FocusTraversalPolicy policy = container.getFocusTraversalPolicy();
    if( null == policy )
        policy = kfm.getDefaultFocusTraversalPolicy();
    Component next = focusNext ? policy.getComponentAfter( container, CategoryList.this )
                              : policy.getComponentBefore( container, CategoryList.this );
    if( null != next && next instanceof CategoryButton ) {
        clearSelection();
        next.requestFocus();
    }
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
public static synchronized void install() {
    if(installed) {
        return;
    }
    
    ShortcutAndMenuKeyEventProcessor instance = getDefault();
    
    KeyboardFocusManager keyboardFocusManager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
    keyboardFocusManager.addKeyEventDispatcher(instance);
    keyboardFocusManager.addKeyEventPostProcessor(instance);
    // #63252: Disable focus traversal functionality of Ctrl+Tab and Ctrl+Shift+Tab,
    // to allow our own document switching (RecentViewListAction)
    defaultForward = keyboardFocusManager.getDefaultFocusTraversalKeys(
                        KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);
    defaultBackward = keyboardFocusManager.getDefaultFocusTraversalKeys(
                        KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS);
    keyboardFocusManager.setDefaultFocusTraversalKeys(
        KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
        Collections.singleton(AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB, 0))
    );                
    keyboardFocusManager.setDefaultFocusTraversalKeys(
        KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS,
        Collections.singleton(AWTKeyStroke.getAWTKeyStroke(KeyEvent.VK_TAB, KeyEvent.SHIFT_DOWN_MASK))
    );                
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
public static synchronized void uninstall() {
    if(!installed) {
        return;
    }
    
    ShortcutAndMenuKeyEventProcessor instance = getDefault();
    
    KeyboardFocusManager keyboardFocusManager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
    keyboardFocusManager.removeKeyEventDispatcher(instance);
    keyboardFocusManager.removeKeyEventPostProcessor(instance);
    // reset default focus traversal keys
    keyboardFocusManager.setDefaultFocusTraversalKeys(
            KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS, defaultForward
    );                
    keyboardFocusManager.setDefaultFocusTraversalKeys(
            KeyboardFocusManager.BACKWARD_TRAVERSAL_KEYS, defaultBackward
    );                
    defaultBackward = null;
    defaultForward = null;
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
private CutCopyPasteDeleteAction(String i18nKey, String action) {
	super(i18nKey);
	putValue(ACTION_COMMAND_KEY, action);
	KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
	manager.addPropertyChangeListener("permanentFocusOwner", new PropertyChangeListener() {

		@Override
		public void propertyChange(PropertyChangeEvent evt) {
			Object o = evt.getNewValue();
			if (o instanceof JComponent) {
				focusOwner = (JComponent) o;
			} else {
				focusOwner = null;
			}
		}
	});
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
public static void main(String[] args) {
    boolean all_passed = true;
    KeyboardFocusManager testKFM = new TestKFM(robot);
    KeyboardFocusManager defKFM = KeyboardFocusManager.getCurrentKeyboardFocusManager();

    for (int i = 0; i < 10; i++) {
        test(testKFM, defKFM);
        Util.waitForIdle(robot);
        System.out.println("Iter " + i + ": " + (lock.get() ? "passed." : "failed!"));
        if (!lock.get()) {
            all_passed = false;
        }
    }
    if (!all_passed) {
        throw new RuntimeException("Test failed: not all iterations passed!");
    }
    System.out.println("Test passed.");
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
@Override
public void run() {
    KeyboardFocusManager m = KeyboardFocusManager.getCurrentKeyboardFocusManager();
    m.removePropertyChangeListener("permanentFocusOwner", this); // NOI18N
    m.addPropertyChangeListener("permanentFocusOwner", this); // NOI18N
    setFocusOwner(m.getPermanentFocusOwner());
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
@Override
public void mouseEntered(MouseEvent e) {
    KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
    lastFocusOwner = kfm.getFocusOwner();
    if (lastFocusOwner != null) {
        lastFocusOwner.addKeyListener(this);
    }
    if (!canDrag(e)) {
        setSelectCursor();
    }
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
/**
 * Creates a new instance of MapEventHandler
 *
 * @param mapComponent The MapComponent for which this MapEventHandler
 * receives events.
 */
public MapEventHandler(MapComponent mapComponent) {
    this.mapComponent = mapComponent;
    mapComponent.addMouseListener(this);
    mapComponent.addMouseMotionListener(this);
    mapComponent.addMouseWheelListener(this);

    KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
    kfm.addKeyEventDispatcher(this);
    mapTool = new SelectionTool(mapComponent);
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
private void doReturn() {
    KeyboardFocusManager fmgr =
        KeyboardFocusManager.getCurrentKeyboardFocusManager();
    Component focusOwner = fmgr.getFocusOwner();
    if(focusOwner != null && !(focusOwner instanceof JRootPane)) {
        return;
    }

    MenuSelectionManager msm = MenuSelectionManager.defaultManager();
    MenuElement path[] = msm.getSelectedPath();
    MenuElement lastElement;
    if(path.length > 0) {
        lastElement = path[path.length-1];
        if(lastElement instanceof JMenu) {
            MenuElement newPath[] = new MenuElement[path.length+1];
            System.arraycopy(path,0,newPath,0,path.length);
            newPath[path.length] = ((JMenu)lastElement).getPopupMenu();
            msm.setSelectedPath(newPath);
        } else if(lastElement instanceof JMenuItem) {
            JMenuItem mi = (JMenuItem)lastElement;

            if (mi.getUI() instanceof BasicMenuItemUI) {
                ((BasicMenuItemUI)mi.getUI()).doClick(msm);
            }
            else {
                msm.clearSelectedPath();
                mi.doClick(0);
            }
        }
    }
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
private void initializeJFrame(int nrows, int ncols) {
	_nrows = nrows;
	_ncols = ncols;
	
    setTitle("2048");
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setLayout(new GridLayout(nrows, ncols));
    
    ImageIcon icon = new ImageIcon("images/button_background.png");
    
    _buttons = new JButton[_nrows][_ncols];
    for (int i = 0; i < nrows; i++) {
    	for (int j = 0; j < ncols; j++) {
    		//_buttons[i][j] = new JButton(String.format("%d", values[i][j]));
    		_buttons[i][j] = new JButton(String.format("%d,%d", i,j));
    		_buttons[i][j].setIcon(icon);
    		_buttons[i][j].setHorizontalTextPosition(SwingConstants.CENTER);
    		_buttons[i][j].setFont(new Font("Arial", Font.PLAIN, 40));
    		add(_buttons[i][j]);
    	}
    }
    setResizable(false);
    setSize(1000, 1000);
    pack();
    setVisible(true);
    setFocusable(true);
	setFocusTraversalKeysEnabled(false);
    //add(new JTextField());
    KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
    manager.addKeyEventDispatcher(new MyDispatcher(this));
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
public void init() {
    robot = Util.createRobot();
    kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
    Toolkit.getDefaultToolkit().addAWTEventListener(new AWTEventListener() {
        public void eventDispatched(AWTEvent event) {
            System.out.println("--> " + event);
        }
    }, FocusEvent.FOCUS_EVENT_MASK | WindowEvent.WINDOW_FOCUS_EVENT_MASK);
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
public static void main(String[] args) throws InterruptedException, java.lang.reflect.InvocationTargetException
{
    final Frame frame = new Frame("the test");
    frame.setLayout(new FlowLayout());
    final Button btn1 = new Button("button 1");
    frame.add(btn1);
    frame.add(new Button("button 2"));
    frame.add(new Button("button 3"));
    frame.pack();
    frame.setVisible(true);

    Robot r = Util.createRobot();
    Util.waitForIdle(r);
    Util.clickOnComp(btn1, r);
    Util.waitForIdle(r);
    KeyboardFocusManager kfm = KeyboardFocusManager.getCurrentKeyboardFocusManager();
    if (kfm.getFocusOwner() != btn1) {
        throw new RuntimeException("test error: can not set focus on " + btn1 + ".");
    }

    EventQueue.invokeAndWait(new Runnable() {
            public void run() {
                final int n_comps = frame.getComponentCount();
                for (int i = 0; i < n_comps; ++i) {
                    frame.getComponent(i).setVisible(false);
                }
            }
        });
    Util.waitForIdle(r);
    final Component focus_owner = kfm.getFocusOwner();

    if (focus_owner != null && !focus_owner.isVisible()) {
        throw new RuntimeException("we have invisible focus owner");
    }
    System.out.println("test passed");
    frame.dispose();
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
/**
 * Dump some of the queued key events back into the regular event system.
 */
private void _dumpQueue(int count)
{
    KeyboardFocusManager mgr = KeyboardFocusManager.getCurrentKeyboardFocusManager();
    while ((count > 0) && (queue.size() > 0))
    {
        KeyEvent ke = queue.pop();
        mgr.redispatchEvent(ke.getComponent(), ke);
        count--;
    }
}
 

import java.awt.KeyboardFocusManager; //导入方法依赖的package包/类
void startTransform(){
    //Create and instance of the analysis class
    guiInput = new Hough_Circle();
    
    KeyboardFocusManager manager = KeyboardFocusManager.getCurrentKeyboardFocusManager();
    manager.addKeyEventDispatcher(new MyDispatcher());
    
    //Add an action listener to the status to allow for GUI to be updated
    //Code modified from: http://www.javacreed.com/swing-worker-example/

    guiInput.addPropertyChangeListener((final PropertyChangeEvent event) -> {
        switch (event.getPropertyName()) {
            
            //If event has progress flag, update progress bar
            case "progress":
                barString = guiInput.getStatus();
                if(isGUI){
                    guiProgressBar.setIndeterminate(false);
                    guiProgressBar.setValue((Integer) event.getNewValue()); 
                    guiProgressBar.setString(barString);
                }
                break;
                
            //if event has state flag, it indicates thread completion status
            case "state":
                switch ((StateValue) event.getNewValue()) {
                    
                    //If worker thread is done, then clear out progress indicators and set button to "OK"
                    case DONE:
                        IJ.showProgress(0);
                        if(isGUI){
                            guiProgressBar.setVisible(false);
                            guiOKButton.setText("OK");
                        }
                        analysisStarted = false;
                        IJ.showStatus("Analysis complete...");
                        break;
                        
                    //If worker has just started, set progress to indetertminate, to let user know plugin is active
                    case STARTED:
                        if(isGUI){
                            guiProgressBar.setVisible(true);
                            guiProgressBar.setIndeterminate(true);
                            guiProgressBar.setString("Starting Transform...");
                        }
                        break;
                    case PENDING:
                        if(isGUI){
                            guiProgressBar.setVisible(true);
                            guiProgressBar.setIndeterminate(true);
                        }
                        break;
                }
                break;
        }
    });

    //Start the background transform by sending the GUI variables to the transform
    guiInput.setParameters(radiusMin, radiusMax, radiusInc, minCircles, maxCircles, thresholdRatio, resolution, ratio, searchBand, 
            searchRadius, reduce, local, houghSeries, showCircles, showID, showScores, results, isGUI);

    //Start the analysis on a separate thread so the GUI stays free.
    guiInput.execute();
}