Study & Dev | Blog Archive | Про java swing

Про java swing - часть 3

January 16, 2008

Менеджеры раскладок

Для графических библиотек java начиная с awt было не характерно управление расположением элементов на форме с помощью задания координат элементов с точностью до пикселя. Ранее мы перед добавлением элементов делали вызов контейнер.setLayout (null). Этим мы отказывались от услуг "менеджеров управления размещением элементов". И после добавления элемента были вынуждены указать для элемента его местоположение и размеры (с точностью до пикселя). Также мы были должны добавить обработчик события для изменения размеров компонента (панели или формы) и в этом обработчике мы пересчитывали координаты элемента. Хотя такой способ дает определенные преимущества, он занимает слишком много времени и чаще можно обойтись использованием "типовых методик расположения элементов".

public static void main(String[] args) {

  JFrame jf = new JFrame("Old Layout Model");

```
  jf.getContentPane().setLayout(null);
```

  final JLabel lab = new JLabel("Label Object");

  lab.setBorder (new TitledBorder ("Текстовая надпись"));

```
  jf.getContentPane().add (lab);
```
```
 
```

  jf.getContentPane().addComponentListener(

```
    new ComponentAdapter() {
```

      public void componentResized(ComponentEvent e) {

        Dimension d  = e.getComponent().getSize();

        Dimension pd = lab.getPreferredSize();

        int l = (d.width - pd.width) / 2;

        int t = (d.height - pd.height) / 2;

        lab.setBounds(l , t, pd.width , pd.height);

```
      }
```
```
    }
```
```
  );
```
```
  jf.setVisible(true);
```
```
}
```

Данный способ плох тем, что мы вынуждены пересчитывать местоположение и размеры элементов, выполняя типовые расчеты. Можем забыть расположить какой-нибудь элемент. Также, мы рассредотачиваем код в нескольких местах, теряя контроль за ним. Рекомендуемым способ является использование менеджеров раскладки. Это класс, который присоединяется к некоторому классу контейнеру и реагирует на изменение его размеров, затем переупорядочивает элементы. Концепция менеджеров основана на том, что каждый компонент может предоставить ему информацию о своих размерах с помощью методов:

final JLabel lab = new JLabel("Label Object"){

   public Dimension getPreferredSize() {

```
     return new Dimension (200 , 25);
```
```
   }
```
```
 
```
```
   public Dimension getMinimumSize() {
```
```
     return new Dimension (100 , 10);
```
```
   }
```
```
 
```
```
   public Dimension getMaximumSize() {
```
```
     return new Dimension (300 , 100);
```
```
   }
```
```
};
```

Например, созданная с помощью такого наследования текстовая надпись не может быть уменьшена менее чем (100*10), не может быть более чем (300*100) и, если есть возможность задать размер без ограничений, то ее размер будет (200*100).

Примечание: данные методы носят характер совещательных. Менеджеры раскладок должны принимать их во внимание, но если что-то не получается, то менеджер раскладки может их и не учитывать.

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

lab.setMaximumSize(new Dimension (200 , 400));

 lab.setMinimumSize(new Dimension (100 , 200));

 lab.setPreferredSize(new Dimension (150 , 250));

Наиболее известными менеджерами расладок являются: BorderLayout, GridLayout

 <strong>BorderLayout</strong>

Данная раскладка предназначена для расположения пяти элементов согласно частям света.

JFrame jf = new JFrame("BorderLayout Example");

```
 int hgap = 10, vgap = 20;
```

 jf.getContentPane().setLayout(new BorderLayout (hgap , vgap));

 jf.getContentPane().add (new JLabel ("North") , BorderLayout.NORTH);

 jf.getContentPane().add (new JLabel ("South") , BorderLayout.SOUTH);

 jf.getContentPane().add (new JLabel ("West") , BorderLayout.WEST);

 jf.getContentPane().add (new JLabel ("East") , BorderLayout.EAST);

 jf.getContentPane().add (new JLabel ("Center") , BorderLayout.CENTER);

 Component cmps [] =  jf.getContentPane().getComponents();

 for (int i = 0; i < cmps.length; i++) {

   JComponent cmp = (JComponent)cmps[i];

   cmp.setBorder(new TitledBorder ("Border: "+ i));

```
 }
```
```
 jf.pack ();
```
```
 jf.setVisible(true);
```

 <strong>GridLayout</strong>

Данная раскладка размещает произвольное количество элементов, располагая их в прямоугольнике размеров X строк на Y столбцов. Размеры всех элементов идентичны.

JFrame jf = new JFrame("GridLayout Example");

jf.getContentPane().setLayout(new GridLayout(/*rows*/4 , /*cols*/3));

```
Random r = new Random();
```
```
for (int i  =  0; i < 4; i++)
```
```
   for (int j  =  0; j < 3; j++){
```

     JLabel lab = new JLabel (i + ", " + j);

     lab.setBorder(new TitledBorder(""+ (char)('A' + Math.abs(r.nextInt())%26) ) );

     Color fg = new Color (0 , Math.abs(r.nextInt()) % 255 , Math.abs(r.nextInt()) % 255);

```
     lab.setForeground(fg);
```
```
     jf.getContentPane().add (lab);
```
```
   }
```
```
   jf.pack ();
```
```
   jf.setVisible(true);
```

Элементы управления список и падающий список

Класс Jlist представляет собой группу элементов отображаемых в одну или несколько колонок. Т.к. элементов может быть много, то одновременно со список можно использовать компоненты JscrollPane. Дело в том, что размер Jlist создается именно таким, чтобы полностью уместить все элементы. Так что, если вы не поместите список внутрь области прокрутки - он будет слишком велик и может не уместиться на экране.

При создании списка можно использовать несколько видов конструторов: в простейшем случае вы можете сразу при создании списка указать все элементы:

JFrame.setDefaultLookAndFeelDecorated(true);

```
JFrame jf = new JFrame("D&D 2");
```

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

```
 
```
```
Vector vec = new Vector();
```
```
vec.add("Apple");
```
```
vec.add("Orange");
```
```
vec.add("Grapes");
```
```
JList list1 = new JList(vec);
```

JList list2 = new JList(new String[]{"Apple (0)", "Orange (0)", "Grapes (0)"});

```
 
```
```
class MegaFruit {
```
```
    String fruitName;
```
```
 
```

    public MegaFruit(String fruitName) {

```
        this.fruitName = fruitName;
```
```
    }
```
```
 
```
```
    public String toString() {
```

        return "MegaFruit: " + fruitName;

```
    }
```
```
}
```

JList list3 = new JList(new MegaFruit[]{new MegaFruit("Apple (M)"),

        new MegaFruit("Orange (M)"), new MegaFruit("Grapes (M)")});

jf.getContentPane().add(list1, BorderLayout.WEST);

jf.getContentPane().add(list2, BorderLayout.CENTER);

jf.getContentPane().add(list3, BorderLayout.EAST);

```
jf.pack();
```
```
jf.setVisible(true);
```

Обратите внимание, на то что в третьем случае в качестве хранимых элементов в списке помещаются не строки (как в двух предыдущих), а произвольные объекты. Всмомните, что для swing ключевой является концепция MVC: когда мы отделяем данные от их представления. В простейшем случае, в списке хранятся не строки, а объекты представляющие часть предметной области. Другое дело, что нужен способ их отображать. Для этого любой класс помещаемый в список должен иметь переопределенный метод toString, результат вызова которого и отображается в списке.

При размещении элементов можно управлять их порядком (в примере они располагаются друг за другом вертикально), хотя такое поведение можно поведение изменить с помощью вызова:

list1.setLayoutOrientation (JList.VERTICAL); //  стиль размещения элементов в списке - вертикальный

list1.setVisibleRowCount(2); // управлением количества видимых строк в списке (влияет на предпочтимый размер списка)

```
 
```

list2.setLayoutOrientation (JList.VERTICAL_WRAP);// тоже вертикальный, но уже с переносом

list2.setVisibleRowCount(2);// управлением количества видимых строк в списке

```
 
```

list3.setLayoutOrientation (JList.HORIZONTAL_WRAP); // стиль размещения элементов - горизонтальный

list3.setVisibleRowCount(1);// управлением количества видимых строк в списке

Теперь самое интересное: последний вариант конструктора Jlist получает в качестве параметра ссылку на объект ListModel. Каждый элемент управления, отображающий данные, имеет связанный с ним объект МОДЕЛИ_ДАННЫХ. Для изменения отображаемой информации следует обращаться не к элементу управления, а к его модели. Класс ListModel содержит множество абстрактных методов (для добавления, удаления, изменения и прочее элементов). В практике удобно использовать так называемые модели по умолчанию, они есть практически для всех элементов управления и моделей, для списка этот класс DefaultListModel.

В качестве примера я создаю окно, содержащее список; затем добавляю обработчик события щелчка по списку. И в зависимости от того, какой кнопкой был выполнен щелчок выполняю некоторую работу. Так если клик был выполнен левой кнопой мыши, то в список добавляется новый элемент, в котором содержится координаты точки нажатия. При нажатии на правую кнопку элемент, по которому был выполнен щелчок, удаляется.

JFrame.setDefaultLookAndFeelDecorated(true);

```
JFrame jf = new JFrame("D&D 2");
```

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

```
 
```

final DefaultListModel dataModel = new DefaultListModel ();

final JList fruits = new JList(dataModel);

```
fruits.addMouseListener(
```
```
  new MouseAdapter() {
```

    public void mouseClicked(MouseEvent e) {

     if (e.getButton() == MouseEvent.BUTTON1)

       dataModel.addElement("ListClick: " + e.getPoint());

```
     else
```

       for (int i = 0; i < dataModel.getSize(); i++){

         Rectangle r = fruits.getCellBounds(i, i);

```
         if (r.contains(e.getPoint())){
```

           dataModel.removeElementAt(i);

```
           return;
```
```
         }
```
```
       }
```
```
     }
```
```
  }
```
```
);
```

jf.getContentPane().add(fruits, BorderLayout.CENTER);

```
 
```
```
jf.pack();
```
```
jf.setVisible(true);
```

Примечание: обратите внимание на то, как опеределяется то, по какому элементу был выполнен правый щелчок. Для этого я обращаясь к модели данных. Затем узнаю количестов элементов в модели, в цикле прохожу их все и определяю координаты, которые занимает на экране каждый конкретный элемент. Когда меня интересую данные - я использую модель. Когда же мне нужна визуализация (например, положение элемента) - обращаюсь к списку. Именно в таком распределении обязанностей в библиотеке swing прослеживается использование модели MVC.

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

fruits.getSelectedIndex() // получаем номер одного выбранного элемента

fruits.getSelectedIndices() // получаем массив целых чисел, в которых хранятся номера

                            // тех элементов, которые были выбраны

fruits.getSelectedValue() // возвращается не индекс, а, именно, ОБЪЕКТ

fruits.getSelectedValues() // в случае выделения множества элементов возвращается массив ОБЪЕКТОВ

```
 
```

fruits.getSelectionMode() // здесь возращается константа, кодирующая доступные режимы выделения элементов.

fruits.getSelectionModel ()  // возвращается модель выделения.

Для изменения выделения можно использовать методы:

fruits.setSelectedIndex() // в качестве параметра будет передан номер выбираемого элемента

fruits.setSelectedIndices() // то же, но не один элемент, а несколько номеров

```
 
```

fruits.setSelectedValue() // установить выбранный ОБЪЕКТ (входой параметр)

fruits.setSelectionMode() // изменить стиль выделения элементов

```
 
```

fruits.setSelectionModel () // установить новую модель выделения.

Для задания стиля выделения можно использовать константы:

 SINGLE_SELECTION - только один элемент может быть выбран.
 SINGLE_INTERVAL_SELECTION - можно выбрать несколько элементов но они должны образовывать один сплошной интервал.
 MULTIPLE_INTERVAL_SELECTION - можно выбирать несколько элементов в любой комбинации.

Фактически, все операции связанные с выделением элементов списка можно выполнить используя модель выделения. В примере ниже, создается список из 20 элементов, затем очищается текущее выделение, затем устанавливается режим <любое выделение>, выделяются два интервала 0-2 и 3-4. Последним шагом затем из получившегося выделения исключается отрезок с 1 - до 3. В результате остается выделеными только элементы номер 0 и 4.

```
for (int i = 0; i < 20; i++)
```

  dataModel.addElement("Element # " + i);

```
 
```

ListSelectionModel selmodel = fruits.getSelectionModel();

// получили ссылку на модель выделения элементов

```
selmodel.clearSelection();
```
```
// очистили выделение
```

System.out.println (" (0) is selected " + selmodel.isSelectedIndex(0));

// определяем выделен ли сейчас элемент списка под номером 0

// изменяем стиль выделения на МНОЖЕСТВО ЭЛЕМЕНТОВ В ПРОИЗВОЛЬНОМ ПОРЯДКЕ

selmodel.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);

// выделяем интервал 0-2

```
selmodel.addSelectionInterval(0 , 2);
```

// выделяем второй интервал 3-4

```
selmodel.addSelectionInterval(3 , 4);
```

// удаляем выделение в отрезке  1-3

```
selmodel.removeSelectionInterval(1,3);
```

Следующий шаг: настройка того, как будут отображаться элементы в списке. Модель MVC требует, чтобы приложение могло управлять внешним видом элементов спискаю В модели Список-Модель_Данных есть еще третий элемент - renderer. Класс, который должен сформировать картинку отображаемого элемента. В следующем примере я получаю список всех доступных для java-приложения шрифтов, затем помещаю в список имена этих шрифтов. При наведении мыши на элемент списка появляется всплывающая подсказка оформленная с использованием данного шрифта.

Примечание: обратите внимание на способ каким я изменяю шрифт. Хотя в составе каждого визуального компонента еще со времен AWT есть метод setFont (для установки шрифта). Но сейчас пользоваться им становится несколько опасно (часто это приводит к непонятным ошибкам). Наилучшее решение - задавать оформление элементов (в том числе и шрифтовое) используя HTML код.

Для того, чтобы вывести увеличенную версию шрифта на который наведен указатель мыши, я использую стандартный метод в составе классов, которые представляют сложные элементы управления состоящие из нескольких частей. Ведь для каждой из этих частей может соответствовать различная подсказка. Интересно, что все swing элементы управления - по определению сложные элементы, следовательно для любого элемента (не только списка, но и текстовой надписи, кнопки) мы можем создать контекстно-зависимую подсказку. Ранее мы уже изменяли подсказку используя метод setTooltipText, но данный способ был слишком "глобальным".

Падающий список

Для создания падающего списка используется класс JcomboBox. Пользователь может выбирать один из нескольких вариантов либо ввести собственное значение в поле редактирования.

Использование JcomboBox практически идентично обычному списку Jlist. Вы также должны создать модель данных, в которой будут находиться элементы данных. По желанию вы добавляете рендерер. В качестве примера создается форма, на которой расположен падающий список с именами HTML файлов находящихя в текущем каталоге. При разветывании списка создается для каждого элемента небольшая картинка preview содержимого этой html-страницы и после выбора ее полное содержимое отображается в элементе Jlabel.

JFrame.setDefaultLookAndFeelDecorated(true);

```
 final JFrame jf = new JFrame("D&D 2");
```

 jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

```
 
```

 DefaultComboBoxModel dataModel = new DefaultComboBoxModel ();

 // создаем модель данных для списка и заполняем ее всеми файлами в некотором каталоге

 // файлами имеющими расширение htm, или html

 final JComboBox fruits = new JComboBox(dataModel);

 File [] fls = new File ("C:\\tmp\\html").listFiles(

```
         new FilenameFilter() {
```

             public boolean accept(File dir, String name) {

                 return name.toLowerCase().endsWith("html") || name.toLowerCase().endsWith("htm");

```
             }
```
```
         }
```
```
 );
```
```
 for (int i = 0; i < fls.length; i++) {
```
```
     dataModel.addElement(fls[i]);
```
```
 }
```

 jf.getContentPane().add (fruits, BorderLayout.NORTH);

```
 fruits.setRenderer(
```

         // создаем Reenderer-выполняющий настройку внешнего вида элемента списка

```
         new ListCellRenderer() {
```

             HashMap< Object, JComponent> mappings = new HashMap<Object, JComponent>();

```
 
```

             public Component getListCellRendererComponent(

                     JList list, Object value, int index, boolean isSelected, boolean cellHasFocus) {

```
                 try {
```

                     if (value == null) return new JLabel ("Выберите элемент из списка");

                     // конечно каждый раз заново выполнять чтение содержимого файла и конструирование глупо,

                     //поэтому создаю кэш

                     if (mappings.containsKey(value))return mappings.get (value);

```
 
```

                     BufferedReader brin = new BufferedReader (new FileReader((File) value));

                     char [] data = new char [(int) ((File) value).length()];

                     int cnt = brin.read(data);

                     String html = new String (data, 0 , cnt).trim();

                     JLabel lab = new JLabel(html);

                     lab.setBorder(new TitledBorder("Документ: " + ((File)value).getCanonicalPath() ));

                     final JScrollPane pane = new JScrollPane(lab);

                     mappings.put (value, pane);

```
                     return pane;
```
```
 
```

                 } catch (IOException e) {

                     e.printStackTrace();

```
                 }
```

                 return new JLabel ("Error. cannot renderer html file ");

```
             }
```
```
         }
```
```
 );
```
```
 fruits.setMaximumRowCount(5);
```

 fruits.setPreferredSize(new Dimension(200 , 50));

```
 
```

 final JLabel lab_info = new JLabel("Выберите из списка файл и увидите его содержимое");

 jf.getContentPane().add (new JScrollPane(lab_info), BorderLayout.CENTER);

```
 
```
```
 
```
```
 fruits.addActionListener(
```

         // обработчик события - был выбран элемент списка

         // значит нужно прочитать файл и отобразить его внизу после падающего списка

```
         new ActionListener() {
```

             public void actionPerformed(ActionEvent e) {

```
                 try {
```

                     File f = (File) fruits.getSelectedItem();

                     BufferedReader brin = new BufferedReader (new FileReader(f));

                     char [] data = new char [(int) f.length()];

                     int cnt = brin.read(data);

                     String html = new String (data, 0 , cnt).trim();

                     lab_info.setText (html);

```
                     jf.pack ();
```

                 } catch (IOException e1) {

                     e1.printStackTrace();

```
                 }
```
```
 
```
```
             }
```
```
         }
```
```
 );
```
```
 
```
```
 jf.pack ();
```
```
 jf.setVisible(true);
```

Редакторы

Концепция редакторов основана на том, что информация, которую мы отображаем с помощью некоторого элемента управления должна редактироваться. Часто, при редактировании, ввод информации довольно сложен, требует проверок, организации интерфейса зависимого от действий пользователя. Например, в списке отображаются файлы и вы хотите изменить некоторый файл. Вы выполняете двойной клик на элементе списка и элемент изменяется, например, появляется панель, с переключателями: выбрать файл на диске или создать новый пустой файл на основании буфера обмена и т.д. В общем, когда нужно редактировать отображаемую информацию в элементе управления, то этот элемент создает класс <редактор> и отображает его. В качестве примера далее приводится форма, в которой есть список элементов (кодирующих цвет) при клике на кнопке <изменить цвет> появляется панель выбора цвета.

JFrame.setDefaultLookAndFeelDecorated(true);

```
final JFrame jf = new JFrame("D&D 2");
```

jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE

```
);
```

// создаем модель данных, в которой будут находиться цвета.

final DefaultComboBoxModel dataModel = new DefaultComboBoxModel();

// создаем падающий список на базе данной модели

final JComboBox fruits = new JComboBox(dataModel);

// объект Random служит для генерации случайных чисел

```
Random r = new Random();
```
```
for (int i = 0; i < 10; i++) {
```

    // заполняем модель случайными цветами

    dataModel.addElement(new Color(Math.abs(r.nextInt()) % 255,

            Math.abs(r.nextInt() % 255),

            Math.abs(r.nextInt() % 255)));

```
}
```

fruits.setRenderer(new ListCellRenderer() {

    // устанавливаем объект рендерер

```
    JLabel jLabel = new JLabel();
```
```
 
```

    // естественно, что необходимо организовать

    // повторное использование компонента JLabel

    public Component getListCellRendererComponent(

            JList list, Object value, int index, boolean isSelected, boolean cellHasFocus

```
    ) {
```

        // когда нас просят вернуть графическое представление объекта - цвета,

        // то возвращается объект Jlabel с надписью кодирующей цвет

        // и цветом фона установленным в значение объекта

```
        Color c = (Color) value;
```

        jLabel.setText("red:" + c.getRed() + "; green: " + c.getGreen() + "; blue: " + c.getBlue());

        // здесь устанавливаем цвет

```
        jLabel.setForeground(c);
```
```
        return jLabel;
```
```
    }
```
```
});
```

// здесь мы разрешаем редактировать содержимое списка

```
fruits.setEditable(true);
```
```
fruits.setEditor(new ComboBoxEditor() {
```

    // добавляем новый класс редактор

```
    Color c = Color.WHITE;
```

    JColorChooser jch = new JColorChooser(c);

    // класс панели для выбора цвета

```
 
```

    public Component getEditorComponent() {

        // данный метод вызывается, когда необходимо создать компонент, который будет играть роль редактора

        final JButton btn_act = new JButton("Изменить цвет");

        // создаем кнопку, при нажатии на которую сработает слушатель события

        // и будет показано всплывающее диалоговое окно выбора цвета

```
 
```

        btn_act.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {

                // при нажатии на кнопку мы получаем текущий цвет c.

                // далее в методах setItem

                jch.getSelectionModel().setSelectedColor(c);

                // обращаемся к классу панели выбора цвета и устанавливаем данный цвет как текущий

                JColorChooser.createDialog(btn_act,

                        // создаем диалоговое окно с панелью выбора цвета

                        "Новый цвет", true, jch,

                        new ActionListener() {

                            // важно здесь создается обработчки события OK

```
 
```

                            public void actionPerformed(ActionEvent e) {

                                int p = dataModel.getIndexOf(c);

                                dataModel.removeElementAt(p);

                                c = jch.getSelectionModel().getSelectedColor();

                                dataModel.insertElementAt(c, p);

```
                            }
```

                        }, /* Здесь можно было бы задать обработчик события CANCEL*/ null)

                        .setVisible(true);

                // и коказываем данное окно

```
 
```
```
            }
```
```
        });
```
```
        return btn_act;
```
```
    }
```
```
 
```

    public void setItem(Object anObject) {

```
        c = (Color) anObject;
```
```
    }
```
```
 
```
```
    public Object getItem() {
```
```
        return c;
```
```
    }
```
```
 
```
```
    public void selectAll() {}
```
```
 
```

    public void addActionListener(ActionListener l) {}

```
 
```

    public void removeActionListener(ActionListener l) {}

```
});
```

fruits.setPreferredSize(new Dimension(200, 50));

```
jf.getContentPane().add(fruits);
```
```
jf.pack();
```
```
jf.setVisible(true);
```

Здесь мы столкнулись с объектом JcolorChooser. Данный компонент предназначен для создания панели выбора цвета. Данная панель может быть встроена в любое диалоговое окно как его составная часть. Вы можете создать окно, на котором расположите любое количество этих окон выбора цвета, или же вы можете создать диалоговое окно для выбора цвета.

Итак, существую три способа использования окна выбора цвета:

1. Используя статический вызов метода вы отображаете модальное диалоговое окно. В качестве результата вызова функции вам возвращается выбранный пользователем цвет.

2. Снова используя статический метод вы создаете диалоговое окно как и в предыдущем случае. Но здесь окно более активно и вы можете установить обработчики событий для нажатия на кнопки OK и CANCEL.

3. Создается компоненет JcolorChooser, помещается внутрь некоторой панели и устанавливается обработчик события для реакции на то, когда пользователь будет изменять цвет в компоненте.

public static void main(String[] args) {

    Color nova_color = JColorChooser.showDialog(null, "Выберите цвет", Color.RED);

    // первый способ -  самый простой

    System.out.println("Был выбран цвет : " + nova_color);

```
 
```

    final JColorChooser chooser = new JColorChooser();

    // эта переменная потребуется для двух последующих способов

    ActionListener Act_CANCEL = new ActionListener() {

        // создаем обработчики событий для кнопки OK

        public void actionPerformed(ActionEvent e) {

            System.out.println("Пользователь нажал отмена");

```
        }
```
```
    };
```

    ActionListener Act_OK = new ActionListener() {

        // тоже обработчик события но для нажатия кнопки CANCEL

        public void actionPerformed(ActionEvent e) {

            System.out.println("Пользователь нажал OK и выбрал цвет: " + chooser.getColor());

```
        }
```
```
    };
```
```
 
```
```
    JColorChooser.createDialog(null,
```
```
            "Выберит цвет",
```
```
            true,
```
```
            chooser,
```
```
            Act_OK,
```

            Act_CANCEL).setVisible(true);

    // создаем диалоговое окно и сразу же его показываем

```
 
```

    chooser.getSelectionModel().addChangeListener(

            // добавляе слушателя событий для модели

```
            new ChangeListener() {
```

                // данный метод будет вызываться при любом изменении текущего цвета

                public void stateChanged(ChangeEvent e) {

                    System.out.println("Был выбран новый цвет: " + chooser.getColor());

```
                }
```
```
            }
```
```
    );
```

    JFrame jf = new JFrame("Выбери цвет");

```
    jf.getContentPane().add(chooser);
```

    // добавляем на форму панель выбора цвета

```
    jf.setVisible(true);
```

    // и показываем форму

```
}
```

Окна сообщений

Для того чтобы вывести на экран диалоговое окно с сообщением следует использовать статические методы класса JoptionPane:

Примечание. Для того, чтобы создать окно сообщения используйте метод showMessageDialog. Для создания окна подтверждения некоторого утверждения - showConfirmDialog. И если вам нужно окно для выбора или ввода значения используйте showInputDialog.

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

public static void main(String[] args) {

```
    JOptionPane.showMessageDialog(
```
```
            null,
```

            "Текущее время : " + new Date(),

            "Система извещений о текущем времени",

            JOptionPane.YES_NO_CANCEL_OPTION,

            // разумеется раз это окно сообщения,

            //то варианты доступных кнопок для закрытия окна не могут отличаться от MB_OK

            new ImageIcon("C:\\tmp\\comp.png")

```
    );
```
```
 
```

    SimpleDateFormat sdf = new SimpleDateFormat("EEEE", new Locale("RU"));

    int r = JOptionPane.showConfirmDialog(

```
            null,
```

            "Вы точно уверены, что сегодня " + sdf.format(new Date()),

            "Подтвердение сведений о текущем дне недели",

            JOptionPane.YES_NO_CANCEL_OPTION,

            JOptionPane.INFORMATION_MESSAGE

```
    );
```
```
    if (r == JOptionPane.YES_OPTION)
```

        JOptionPane.showMessageDialog(null, "Подтверждение получено");

```
 
```
```
 
```

    Object ob = JOptionPane.showInputDialog(

            null, "Введите четное число", "Окно для ввода четных чисел",

            JOptionPane.INFORMATION_MESSAGE, new ImageIcon("C:\\tmp\\spic2.jpg"),

            new Integer[]{new Integer(12), new Integer(13), new Integer(14)},

```
            new Integer(12));
```

    JOptionPane.showMessageDialog(null, ob);

```
}
```

Возможные значения опций кнопок закрытия окна	Возможные опции стиля иконки. В последнем случае без иконки.
JOptionPane.YES_OPTION; JOptionPane.YES_NO_OPTION; JOptionPane.YES_NO_CANCEL_OPTION; JOptionPane.NO_OPTION; JOptionPane.CANCEL_OPTION;	JOptionPane.INFORMATION_MESSAGE; JOptionPane.ERROR_MESSAGE; JOptionPane.QUESTION_MESSAGE; JOptionPane.PLAIN_MESSAGE;

Возможные значения опций кнопок закрытия окна

Возможные опции стиля иконки. В последнем случае без иконки.

```
JOptionPane.YES_OPTION;
```
```
JOptionPane.YES_NO_OPTION;
```
```
JOptionPane.YES_NO_CANCEL_OPTION;
```
```
JOptionPane.NO_OPTION;
```
```
JOptionPane.CANCEL_OPTION;
```

```
JOptionPane.INFORMATION_MESSAGE;
```
```
JOptionPane.ERROR_MESSAGE;
```
```
JOptionPane.QUESTION_MESSAGE;
```
```
JOptionPane.PLAIN_MESSAGE;
```

Элементы управления для работы с текстом

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

Компонент	Назначение
JTextField	Однострочная область ввода текста. При завершении ввода и нажатии на генерируется события для слушателя.
JFormattedTextField	Текстовое поле, при вводе в которое можно задать маску или шаблон, которому должны соответствовать вводимые символы.
JPasswordField	Текстовая область для ввода пароля. Вводимые символы закрываются символами подстановки.

В примере дальше создается форма для ввода имени пользователя, пароля и номера телефона по которому он хочет позвонить.

Особое внимание обратите на то, как я создаю объект JformattedTextField. В качестве параметра для его конструктора я передаю ссылку на объект, выполняющий форматирование и контроль за корректностью ввода значения в поле. Фактически, вы можете создать собственный класс, расширяющий интерфейс AbstractFormatter, и реализовать любую сколь угодно сложную проверку. Также вы можете воспользоваться специальными классами-адаптерами. Одним из которых является Formatter. Этот класс получает при создании маску для ограничения ввода значений согласно шаблону. Шаблон состоит из спец. символов согласно нижеприведенной таблице.

Символ	Назначение
#	Любой символ, представляющий цифру
'	Данный символ является Escape-символом и служит для отмены специального значения других символов форматирования.
U	Любой символ представляющий букву (с преобразованием к верхнему регистру)
L	То же, что и выше, но преобразование идет к нижнему регистру
A	Любой символ, представляющий собой букву или цифру
?	Любой символ
*	Все, что угодно.
H	Любой hex символ (0-9, a-f или A-F)

```
JFrame jf = new JFrame("Nova ATS");
```

// это обычное текстовое поле без каких либо ограничений на ввод информации

final JTextField uname = new JTextField("укажите имя пользователя");

```
 
```

// это поле для ввода паролей, все вводимые символы будут закрыты значком '@'

JPasswordField upass = new JPasswordField();

```
upass.setEchoChar('@');
```
```
 
```

// ввод телефон ограничен маской

```
MaskFormatter mf;
```

final JFormattedTextField phone = new JFormattedTextField(

        mf = new MaskFormatter("(###)-###-##-## (UUU)")

```
);
```
```
mf.setPlaceholderCharacter('_');
```
```
 
```

JPanel jp_top = new JPanel(new GridLayout(3, 2));

jp_top.add(new JLabel("Укажите имя пользователя"));

```
jp_top.add(uname);
```

jp_top.add(new JLabel("Укажите пароль"));

```
jp_top.add(upass);
```

jp_top.add(new JLabel("Укажите телефон"));

```
jp_top.add(phone);
```
```
 
```
```
phone.addActionListener(
```
```
        new ActionListener() {
```

            public void actionPerformed(ActionEvent e) {

                JOptionPane.showMessageDialog(null, "Пользователь: " + uname.getText() +

                        " Звонит по номеру : " + phone.getText());

```
            }
```
```
        }
```
```
);
```
```
 
```

jf.getContentPane().add(jp_top, BorderLayout.CENTER);

```
jf.pack();
```
```
jf.setVisible(true);
```

Categories: Java

Study & DevО программировании и не только

Про java swing - часть 3

Менеджеры раскладок

Элементы управления список и падающий список

Падающий список

Редакторы

Окна сообщений

Элементы управления для работы с текстом

Поиск

Недавнее

Архив

Разделы