Как Использовать Подсистему Фокуса

Много компонентов ⠀” даже теми, которыми прежде всего управляют с мышью, такие как кнопки ⠀” можно управлять с клавиатурой. Для нажатия клавиши, чтобы влиять на компонент, у компонента должен быть клавиатурный фокус.

С точки зрения пользователя компонент с клавиатурным фокусом является обычно видным ⠀” с точечной или черной границей, например. Окно, содержащее компонент, является также более видным чем другие экранные окна. Эти визуальные индикаторы, которым сообщают пользователь, к которому компоненту будет иметь отношение любой ввод. Только у одного компонента за один раз в оконной системе может быть клавиатурный фокус.

Точно, как окно получает, фокус зависит от системы управления окнами. Нет никакого надежного способа через все платформы, гарантировать, что окно получает фокус. На некоторых операционных системах, таких как Microsoft Windows, переднее окно обычно становится фокусируемым окном. В этих случаях, Window.toFront метод перемещает окно в переднюю сторону, таким образом давая это фокус. Однако, на других операционных системах, таких как Операционная система Solaris™, менеджер окон может выбрать фокусируемое оконное на позиции курсора, и в этих случаях поведение Window.toFront метод отличается.

Компонент обычно получает фокус, когда пользователь щелкает по этому, или когда пользовательские вкладки между компонентами, или иначе взаимодействует с компонентом. Компоненту можно также дать фокус программно, такой как тогда, когда его содержание фрейма или диалогового окна делается видимым. Этот фрагмент кода шоу, как дать определенному компоненту фокус каждый раз окно, получает фокус:

//Make textField get the focus whenever frame is activated.
frame.addWindowFocusListener(new WindowAdapter() {
    public void windowGainedFocus(WindowEvent e) {
        textField.requestFocusInWindow();
    }
});

Если Вы хотите гарантировать, что определенный компонент получает фокус в первый раз, когда окно активируется, можно вызвать requestFocusInWindow метод на компоненте после компонента был понят, но прежде, чем фрейм будет выведен на экран. Следующий пример кода показывает, как эта работа может быть сделана:

    //...Where initialization occurs...
    JFrame frame = new JFrame("Test");
    JPanel panel = new JPanel(new BorderLayout());

    //...Create a variety of components here...

    //Create the component that will have the initial focus.
    JButton button = new JButton("I am first");
    panel.add(button);
    frame.getContentPane().add(panel);  //Add it to the panel

    frame.pack();  //Realize the components.
    //This button will have the initial focus.
    button.requestFocusInWindow(); 
    frame.setVisible(true); //Display the window.

Альтернативно, можно применить пользовательское FocusTraversalPolicy к фрейму и вызову getDefaultComponent метод, чтобы определить, какой компонент получит фокус.

Остальная часть этого раздела затрагивает следующие темы:

• Введение в Подсистему Фокуса
• Проверка допустимости Ввода
• Создание Пользовательского Компонента Focusable
• Настройка Обхода Фокуса
• Отслеживание Фокуса Изменяется на Многократные Компоненты
• Передачи Фокуса синхронизации
• API Фокуса
• Примеры фокуса

Введение в Подсистему Фокуса

Подсистема фокуса разрабатывается, чтобы сделать правильную вещь настолько незримо насколько возможно. В большинстве случаев это ведет себя разумным способом, и если это не делает можно настроить его поведение различными способами. Некоторые общие сценарии могли бы включать:

• Упорядочивание является правильным, но первый компонент с фокусом не устанавливается. Как показано во фрагменте кода в предыдущем разделе, можно использовать requestFocusInWindow метод, чтобы установить фокус на компоненте, когда окно становится видимым.
• Упорядочивание является неправильным. Чтобы устранить эту проблему, можно изменить иерархию включения, можно изменить порядок, что компоненты добавляются к их контейнерам, или можно создать пользовательскую политику обхода фокуса. Для получения дополнительной информации см. Обход Фокуса Настройки.
• Компонент должен, чтобы препятствоваться терять фокус, или Вы должны проверить значение в компонент прежде, чем это потеряет фокус. Входная проверка является решением этой проблемы.
• Пользовательский компонент не получает фокус. Чтобы устранить эту проблему, Вы должны удостовериться, что она удовлетворяет все требования, обрисованные в общих чертах в Создании Пользовательского Компонента Focusable.

FocusConceptsDemo пример иллюстрирует несколько понятий.

KeyboardFocusManager критический элемент подсистемы фокуса. Это управляет состоянием и инициирует изменения. Менеджер по клавиатуре отслеживает владельца фокуса ⠀” компонент, который получает ввод от клавиатуры. Фокусируемое окно является окном, которое содержит владельца фокуса.

Цикл фокуса (или цикл обхода фокуса) являются рядом компонентов, которые совместно используют общего предка в иерархии включения. Корень цикла фокуса является контейнером, который является корнем для определенного цикла обхода фокуса. По умолчанию, каждый JWindow и JInternalFrame компонент может быть корнем цикла фокуса. Корень цикла фокуса может самостоятельно содержать один или более корней цикла фокуса. Следующие объекты Swing могут быть корнями цикла фокуса: JApplet, JDesktopPane, JDialog, JEditorPane, JFrame, JInternalFrame, и JWindow. В то время как это могло бы казаться это JTable и JTree объекты являются корнями цикла фокуса, они не.

Политика обхода фокуса определяет порядок, в котором группа компонентов перемещаются. Swing обеспечивает LayoutFocusTraversalPolicy class, который решает порядок навигации, основанной на расположении зависимые от менеджера факторы, такие как размер, расположение, и ориентация компонентов. В пределах цикла фокуса по компонентам можно переместиться в прямом или обратном направлении. В иерархии корней цикла фокуса вверх обход вынимает фокус из текущего цикла в родительский цикл.

В большинстве моделей Стили по компонентам перемещаются, используя ключи Shift-Tab и Вкладка. Эти ключи являются ключами обхода фокуса значения по умолчанию и могут быть изменены программно. Например, можно добавить, Входят как прямой ключ обхода фокуса со следующими четырьмя строками кода:

Set forwardKeys = getFocusTraversalKeys(
    KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS);
Set newForwardKeys = new HashSet(forwardKeys);
newForwardKeys.add(KeyStroke.getKeyStroke(KeyEvent.VK_ENTER, 0));
setFocusTraversalKeys(KeyboardFocusManager.FORWARD_TRAVERSAL_KEYS,
    newForwardKeys);

Вкладка смещает фокус в прямом направлении. Shift-Tab перемещает фокус в обратное направление. Например, в FocusConceptsDemo, у первой кнопки есть начальный фокус. Переключение вкладок перемещает фокус через кнопки в текстовую область. Дополнительное переключение вкладок перемещает курсор в пределах текстовой области, но не из текстовой области, потому что в текстовой области Вкладка не является ключом обхода фокуса. Однако, Вкладка управления перемещает фокус из текстовой области и в первое текстовое поле. Аналогично, Вкладка сдвига управления перемещает фокус из текстовой области и в предыдущий компонент. Клавиша CTRL используется условно, чтобы переместить фокус из любого компонента, который обрабатывает Вкладку специальным способом, такой как JTable.

Вы только что получили краткое введение в архитектуру фокуса. Если Вы хотите больше деталей, см. спецификацию для Подсистемы Фокуса.

Проверка допустимости Ввода

Общее требование проекта GUI является компонентом, который ограничивает ввод пользователя ⠀” например, текстовое поле, которое позволяет только числовой ввод в десятичном формате (деньги, например) или текстовое поле, которое позволяет только 5 цифр для почтового индекса. Выпуск 1.4 обеспечивает удобный, удобный в работе отформатированный компонент текстового поля, который позволяет вводу быть ограниченным множеству локализуемых форматов. Можно также определить пользовательское средство форматирования для текстового поля, которое может выполнить специальную проверку, такую как определение, форматируются ли значения не только правильно, но также и разумные.

Можно использовать входной верификатор в качестве альтернативы пользовательскому средству форматирования, или когда у Вас есть компонент, который не является текстовым полем. Входной верификатор позволяет Вам отклонять определенные значения, такие как должным образом отформатированный, но недопустимый почтовый индекс, или значения за пределами требуемого диапазона, например температура тела выше чем 110°F. Чтобы использовать входной верификатор, Вы создаете подкласс InputVerifier (class, представленный в JDK 1.3), создайте экземпляр своего подкласса, и установите экземпляр как входной верификатор для одного или более компонентов.

С входным верификатором компонента консультируются всякий раз, когда компонент собирается потерять фокус. Если значение компонента не является приемлемым, входной верификатор может принять соответствующие меры, такие как отказ привести к фокусу на компоненте или замене ввода пользователя с последним допустимым значением и затем разрешения фокуса передать следующему компоненту. Однако, InputVerifier не вызывается, когда фокус передается другому высокоуровневому компоненту.

Следующие два примера показывают ипотечные калькуляторы. Каждый использует отформатированные текстовые поля и другую входную проверку использования со стандартными текстовыми полями.

Можно найти код для Входного демонстрационного примера Проверки в InputVerificationDemo.java. Вот код для InputVerifier подкласс, MyVerifier:

class MyVerifier extends InputVerifier
                 implements ActionListener {
    double MIN_AMOUNT = 10000.0;
    double MAX_AMOUNT = 10000000.0;
    double MIN_RATE = 0.0;
    int MIN_PERIOD = 1;
    int MAX_PERIOD = 40;

   public boolean shouldYieldFocus(JComponent input) {
        boolean inputOK = verify(input);
        makeItPretty(input);
        updatePayment();

        if (inputOK) {
            return true;
        } else {
            Toolkit.getDefaultToolkit().beep();
            return false;
        }
    }

    protected void updatePayment() {
        double amount = DEFAULT_AMOUNT;
        double rate = DEFAULT_RATE;
        int numPeriods = DEFAULT_PERIOD;
        double payment = 0.0;

        //Parse the values.
        try {
            amount = moneyFormat.parse(amountField.getText()).
                              doubleValue();
        } catch (ParseException pe) {pe.printStackTrace();}
        try {
            rate = percentFormat.parse(rateField.getText()).
                                 doubleValue();
        } catch (ParseException pe) {pe.printStackTrace();}
        try {
            numPeriods = decimalFormat.parse(numPeriodsField.getText()).
                              intValue();
        } catch (ParseException pe) {pe.printStackTrace();}

        //Calculate the result and update the GUI.
        payment = computePayment(amount, rate, numPeriods);
        paymentField.setText(paymentFormat.format(payment));
    }

    //This method checks input, but should cause no side effects.
    public boolean verify(JComponent input) {
        return checkField(input, false);
    }

    protected void makeItPretty(JComponent input) {
        checkField(input, true);
    }

    protected boolean checkField(JComponent input, boolean changeIt) {
        if (input == amountField) {
            return checkAmountField(changeIt);
        } else if (input == rateField) {
            return checkRateField(changeIt);
        } else if (input == numPeriodsField) {
            return checkNumPeriodsField(changeIt);
        } else {
            return true; //should not happen
        }
    }

    //Checks that the amount field is valid.  If it is valid,
    //it returns true; otherwise, returns false.  If the
    //change argument is true, this method sets the
    //value to the minimum or maximum value if necessary and
    // (even if not) sets it to the parsed number so that it
    // looks good -- no letters, for example.
    protected boolean checkAmountField(boolean change) {
        boolean wasValid = true;
        double amount = DEFAULT_AMOUNT;

        //Parse the value.
        try {
            amount = moneyFormat.parse(amountField.getText()).
                              doubleValue();
        } catch (ParseException pe) {
            pe.printStackTrace();
            wasValid = false;
        }

        //Value was invalid.
        if ((amount < MIN_AMOUNT) || (amount > MAX_AMOUNT)) {
            wasValid = false;
            if (change) {
                if (amount < MIN_AMOUNT) {
                    amount = MIN_AMOUNT;
                } else { // amount is greater than MAX_AMOUNT
                    amount = MAX_AMOUNT;
                }
            }
        }

        //Whether value was valid or not, format it nicely.
        if (change) {
            amountField.setText(moneyFormat.format(amount));
            amountField.selectAll();
        }

        return wasValid;
    }

    //Checks that the rate field is valid.  If it is valid,
    //it returns true; otherwise, returns false.  If the
    //change argument is true, this method reigns in the
    //value if necessary and (even if not) sets it to the
    //parsed number so that it looks good -- no letters,
    //for example.
    protected boolean checkRateField(boolean change) {
        ...//Similar to checkAmountField...
    }

    //Checks that the numPeriods field is valid.  If it is valid,
    //it returns true; otherwise, returns false.  If the
    //change argument is true, this method reigns in the
    //value if necessary and (even if not) sets it to the
    //parsed number so that it looks good -- no letters,
    //for example.
    protected boolean checkNumPeriodsField(boolean change) {
        ...//Similar to checkAmountField...
    }

    public void actionPerformed(ActionEvent e) {
        JTextField source = (JTextField)e.getSource();
        shouldYieldFocus(source); //ignore return value
        source.selectAll();
    }
}

Отметьте что verify метод реализуется, чтобы обнаружить недопустимые значения, но не делает ничего иного. verify метод существует только, чтобы определить, является ли ввод допустимым ⠀”, это никогда не должно переводить диалоговое окно в рабочее состояние или вызывать любые другие побочные эффекты. shouldYieldFocus вызовы метода verify и, если значения недопустимо, наборы это к минимальному или максимальному значению. shouldYieldFocus методу позволяют вызвать побочные эффекты, в этом случае, он всегда форматирует текстовое поле и может также изменить его значение. В нашем примере, shouldYieldFocus метод всегда возвращает true так, чтобы передача фокуса никогда не была фактически предотвращена. Это - только один способ, которым может быть реализована проверка. Сочтите другую версию этого демонстрационного примера вызванной InputVerificationDialogDemo это поднимает диалоговое окно, когда ввод данных пользователем недопустим и требует, чтобы пользователь ввел юридическое значение.

Входной верификатор устанавливается, используя setInputVerifier метод JComponent class. Например, InputVerificationDemo имеет следующий код:

private MyVerifier verifier = new MyVerifier();
...
amountField.setInputVerifier(verifier);

Создание Пользовательского Компонента Focusable

Для компонента, чтобы получить фокус, это должно удовлетворить три требования: это должно быть видимо, включенное, и focusable. Входная карта может также быть дана. Для получения дополнительной информации о входной карте, читайте, Как Использовать Привязки клавиш.

Пример TrackFocusDemo определяет простой компонент Picture. Его конструктора показывают ниже:

public Picture(Image image) {
    this.image = image;
    setFocusable(true);
    addMouseListener(this);
    addFocusListener(this);
}

Звонок setFocusable(true) метод делает компонент focusable. Если Вы явно подаете свои компонентные привязки клавиш WHEN_FOCUSED входная карта, Вы не должны вызвать setFocusable метод.

Визуально показать изменения в фокусе (при рисовании красной границы только, когда у компонента есть фокус), Picture имеет слушателя фокуса.

Чтобы получить фокус, когда пользователь щелкает по изображению, у компонента есть слушатель мыши. Слушатель mouseClicked метод запрашивает на фокус быть переданным изображению. Вот код:

public void mouseClicked(MouseEvent e) {
    //Since the user clicked on us, let us get focus!
    requestFocusInWindow();
}

См. Изменения Фокуса Отслеживания к Многократным Компонентам для большего количества обсуждения примера TrackFocusDemo.

Настройка Обхода Фокуса

Подсистема фокуса определяет порядок значения по умолчанию, который применяется при использовании ключей обхода фокуса (таких как Вкладка), чтобы переместиться. Политика приложения Swing определяется LayoutFocusTraversalPolicy . Можно установить политику обхода фокуса по любому Container при использовании setFocusCycleRoot метод. Однако, если контейнер не является корнем цикла фокуса, он не может иметь никакого очевидного эффекта. Альтернативно можно передать провайдеров политики обхода фокуса к FocusTraversalPolicy методы вместо корней цикла фокуса. Используйте isFocusTraversalPolicyProvider() метод, чтобы определить, ли a Container провайдер политики обхода фокуса. Используйте setFocusTraversalPolicyProvider() метод, чтобы установить контейнер для того, чтобы обеспечить политику обхода фокуса.

FocusTraversalDemo пример демонстрирует, как настроить поведение фокуса.

Можно найти код демонстрационного примера в FocusTraversalDemo.java.

Флажок был удален из цикла фокуса с этой строкой кода:

togglePolicy.setFocusable(false);

Вот пользовательское приложение FocusTraversalPolicy:

...
JTextField tf1 = new JTextField("Field 1");
JTextField tf2 = new JTextField("A Bigger Field 2");
JTextField tf3 = new JTextField("Field 3");
JTextField tf4 = new JTextField("A Bigger Field 4");
JTextField tf5 = new JTextField("Field 5");
JTextField tf6 = new JTextField("A Bigger Field 6");
JTable table = new JTable(4,3);
...
public FocusTraversalDemo() {
    super(new BorderLayout());

    JTextField tf1 = new JTextField("Field 1");
    JTextField tf2 = new JTextField("A Bigger Field 2");
    JTextField tf3 = new JTextField("Field 3");
    JTextField tf4 = new JTextField("A Bigger Field 4");
    JTextField tf5 = new JTextField("Field 5");
    JTextField tf6 = new JTextField("A Bigger Field 6");
    JTable table = new JTable(4,3);
    togglePolicy = new JCheckBox("Custom FocusTraversalPolicy");
    togglePolicy.setActionCommand("toggle");
    togglePolicy.addActionListener(this);
    togglePolicy.setFocusable(false);  //Remove it from the focus cycle.
    //Note that HTML is allowed and will break this run of text
    //across two lines.
    label = new JLabel("<html>Use Tab (or Shift-Tab) to navigate from component to component.<p>Control-Tab 
    (or Control-Shift-Tab) allows you to break out of the JTable.</html>");

    JPanel leftTextPanel = new JPanel(new GridLayout(3,2));
    leftTextPanel.add(tf1, BorderLayout.PAGE_START);
    leftTextPanel.add(tf3, BorderLayout.CENTER);
    leftTextPanel.add(tf5, BorderLayout.PAGE_END);
    leftTextPanel.setBorder(BorderFactory.createEmptyBorder(0,0,5,5));
    JPanel rightTextPanel = new JPanel(new GridLayout(3,2));
    rightTextPanel.add(tf2, BorderLayout.PAGE_START);
    rightTextPanel.add(tf4, BorderLayout.CENTER);
    rightTextPanel.add(tf6, BorderLayout.PAGE_END);
    rightTextPanel.setBorder(BorderFactory.createEmptyBorder(0,0,5,5));
    JPanel tablePanel = new JPanel(new GridLayout(0,1));
    tablePanel.add(table, BorderLayout.CENTER);
    tablePanel.setBorder(BorderFactory.createEtchedBorder());
    JPanel bottomPanel = new JPanel(new GridLayout(2,1));
    bottomPanel.add(togglePolicy, BorderLayout.PAGE_START);
    bottomPanel.add(label, BorderLayout.PAGE_END);

    add(leftTextPanel, BorderLayout.LINE_START);
    add(rightTextPanel, BorderLayout.CENTER);
    add(tablePanel, BorderLayout.LINE_END);
    add(bottomPanel, BorderLayout.PAGE_END);
    setBorder(BorderFactory.createEmptyBorder(20,20,20,20));
    Vector<Component> order = new Vector<Component>(7);
    order.add(tf1);
    order.add(tf2);
    order.add(tf3);
    order.add(tf4);
    order.add(tf5);
    order.add(tf6);
    order.add(table);
    newPolicy = new MyOwnFocusTraversalPolicy(order);
}

Использовать пользовательское FocusTraversalPolicy, реализуйте следующий код любого корня цикла фокуса.

    MyOwnFocusTraversalPolicy newPolicy = new MyOwnFocusTraversalPolicy();
    frame.setFocusTraversalPolicy(newPolicy);

Можно удалить пользовательскую политику обхода фокуса, устанавливая FocusTraversalPolicy к null, который восстановит политику значения по умолчанию.

Отслеживание Фокуса Изменяется на Многократные Компоненты

В некоторых ситуациях приложение, возможно, должно отследить, у какого компонента есть фокус. Эта информация могла бы использоваться, чтобы динамически обновить меню или возможно строку состояния. Если Вы должны отследить фокус только на определенных компонентах, может иметь смысл реализовывать слушателя события фокуса.

Если слушатель фокуса не является соответствующим, можно вместо этого зарегистрировать a PropertyChangeListener на KeyboardFocusManager. Слушатель изменения свойства уведомляется относительно каждого изменения, включающего фокус, включая изменения владельцу фокуса, фокусируемому окну, и политике обхода фокуса значения по умолчанию. См. таблицу Свойств KeyboardFocusManager для полного списка.

Следующий пример демонстрирует, как отслеживать владельца фокуса, устанавливая слушателя изменения свойства на менеджере по клавиатурному фокусу.

Можно просмотреть код демонстрационного примера в TrackFocusDemo.java. Пользовательский компонент, используемый для рисования изображений, может быть найден в Picture.java. Вот код, который определяет и устанавливает слушателя изменения свойства:

KeyboardFocusManager focusManager =
    KeyboardFocusManager.getCurrentKeyboardFocusManager();
focusManager.addPropertyChangeListener(
    new PropertyChangeListener() {
        public void propertyChange(PropertyChangeEvent e) {
            String prop = e.getPropertyName();
            if (("focusOwner".equals(prop)) &&
                  ((e.getNewValue()) instanceof Picture)) {
                Component comp = (Component)e.getNewValue();
                String name = comp.getName();
                Integer num = new Integer(name);
                int index = num.intValue();
                if (index < 0 || index > comments.length) {
                    index = 0;
                }
                info.setText(comments[index]);
            }
        }
    }
);

Пользовательский компонент, Picture, ответственно за рисование изображения. Все шесть компонентов определяются этим способом:

pic1 = new Picture(createImageIcon("images/" +
            mayaString + ".gif", mayaString).getImage());
pic1.setName("1");

Передачи Фокуса синхронизации

Передачи фокуса являются асинхронными. Это качество может привести к некоторым нечетным связанным с синхронизацией проблемам и предположениям, особенно во время автоматических передач фокуса. Например, вообразите приложение с окном, содержащим кнопку Start, кнопку Cancel и текстовое поле. Компоненты добавляются в этом порядке:

1. Запустите кнопку
2. Текстовое поле
3. Кнопка отмены

Когда приложение запускается, LayoutFocusTraversalPolicy определяет политику обхода фокуса ⠀” в этом случае, это - порядок, что компоненты были добавлены к их контейнеру. В этом примере требуемое поведение состоит в том, что у кнопки Start есть начальный фокус, и когда кнопка Start нажимается, это отключается, и затем кнопка Cancel получает фокус. Корректный способ реализовать это поведение состоял бы в том, чтобы добавить компоненты к контейнеру в требуемом порядке или создать пользовательскую политику обхода фокуса. Если по некоторым причинам это не возможно, то можно реализовать это поведение со следующим фрагментом кода:

public void actionPerformed(ActionEvent e) {
    //This works.
    start.setEnabled(false);
    cancel.requestFocusInWindow();
}

Как требующийся, фокус идет от кнопки Start до кнопки Cancel, а не к текстовому полю. Но различный результат произошел бы, если бы те же самые методы вызвали в противоположном порядке следующим образом:

public void actionPerformed(ActionEvent e) {
    //This does not work.
    cancel.requestFocusInWindow();
    start.setEnabled(false);
}

В этом случае фокус требуют на кнопке Cancel прежде, чем это оставило кнопку Start. Звонок requestFocusInWindow метод инициирует передачу фокуса, но это сразу не перемещает фокус в кнопку Cancel. Когда кнопка Start отключается, фокус передается следующему компоненту (таким образом, всегда есть компонент с фокусом), и, в этом случае, это тогда переместило бы фокус в текстовое поле, не в кнопку Cancel.

Есть несколько ситуаций, в которых Вы должны обратиться с просьбами фокуса после всех других изменений, которые могли бы влиять на фокус, применяется к:

• Сокрытие владельца фокуса.
• Создание владельца фокуса non-focusable.
• Вызов removeNotify метод на владельце фокуса.
• Выполнение любой из вышеупомянутых операций к контейнеру владельца фокуса, или порождение изменений к политике фокуса так, чтобы контейнер больше не принял компонент как владельца фокуса.
• Избавление от высокоуровневого окна, которое содержит владельца фокуса.

API Фокуса

Следующие таблицы приводят обычно используемых конструкторов и методы, связанные с фокусом. API фокуса попадает в четыре категории:

• Полезные Методы для Компонентов
• Создание и Используя Пользовательский FocusTraversalPolicy
• Входной API Проверки
• Свойства KeyboardFocusManager

Для более подробной информации об архитектуре фокуса см. спецификацию для Подсистемы Фокуса. Можно также найти, Как Записать полезному Слушателю Фокуса.

Полезные Методы для Компонентов

Весь этот API был представлен в JDK 1.4.

Создание и Используя Пользовательский FocusTraversalPolicy

Входной API Проверки

Весь этот API был представлен в JDK 1.3.

Свойства KeyboardFocusManager

Эта таблица определяет связанные свойства для KeyboardFocusManager. Слушатель может быть зарегистрирован для этих свойств, вызывая addPropertyChangeListener.

Весь этот API был представлен в JDK 1.4.

Примеры тот Фокус Использования

Следующая таблица приводит примеры, которые управляют фокусом: