JList list = new JList(data);

list.setVisibleRowCount(2);

list.addListSelectionListener(this);

JScrollPane sp = new JScrollPane(list); f.getContent Pane().add(sp);

Так же, как и в раскрывающийся список JComboBox, в список JList можно занести не только текст, но и изображения.

По умолчанию в списке можно выбрать любое число любых элементов, держа клавишу нажатой. После применения метода

setSelectionMode(ListSelectionModel.SINGLE SELECTION);

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

ListSelectionModel классом DefaultListSelectionModel. Данная реализация модели выбора применяется в классе JList по умолчанию. Если такая реализация почему-либо не устраивает разработчика, то он может реализовать интерфейс ListSelectionModel своим классом и установить созданную модель выбора методом

setSelectionModel(ListSelectionModel).

Один (первый) выбранный элемент можно получить методом getSelectedValue (), массив типа Object [] всех выбранных элементов — методом getSelectedValues (). Индекс первого выбранного элемента выдает метод getSelectedindex(), массив индексов всех выбранных элементов — метод getSelectedIndices ( ).

Кроме модели выбора- реализации интерфейса ListSelectionModel- класс JList свя

зан еще с моделью данных. Она описана интерфейсом ListModel и частично реализована абстрактным классом AbstractListModel. Класс JList использует расширение этого класса — класс DefaultListModel. Класс DefaultListModel хранит данные в закрытом поле delegate типа Vector на основе идеи делегирования и дублирует фактически все методы класса Vector, обращаясь к классу-представителю, например:

public Object getElementAt(int index){ return delegate.elementAt(index);

}

Класс JList отслеживает событие ListSelectionEvent, происходящее при смене выделенного элемента списка. Его модель данных отслеживает, кроме того, событие ListDataEvent, возникающее при всяком изменении списка.

Визуализация элементов списков

Компоненты классов JList и JComboBox могут содержать десятки и сотни элементов, имеющих тип String или Icon. Создание графического объекта для каждого элемента списка приведет к колоссальному расходу оперативной памяти и к большим затратам времени на создание объектов. Чтобы избежать этого расхода ресурсов, для изображения элементов списков назначается объект-рисовальщик. Он последовательно выводит элементы на экран или на принтер, переходя от одного элемента к другому. Короче говоря, реализуется design pattern, известный под именем Flyweight.

Кроме экономии ресурсов такой подход дает возможность вывода каждого элемента списка по-своему, меняя вид элемента, например шрифт или цвет. Класс-рисовальщик описан в интерфейсе ListCellRenderer, имеющем только один метод

public Component getListCellRendererComponent(

JList list, // Список, элементы которого выводятся на экран

// Элемент списка, который будет выведен // Порядковый индекс этого элемента // Выбран ли этот элемент?

Object value, int index, boolean isSelected, boolean cellHasFocus

// Имеет ли фокус этот элемент?

Этот метод должен сформировать компонент и поместить в него текущий элемент списка value, имеющий порядковый номер index. Вид компонента может зависеть не только от его класса или порядкового номера, но и от того, выбран ли он isSelected (обычно выбранный элемент выделяется синим цветом фона) и имеет ли фокус cellHasFocus (обычно обводится тонкой рамкой). Полученный компонент затем выводится на экран своим методом paint ( ).

В библиотеке Swing интерфейс ListCellRenderer реализован классами BasicComboBoxRenderer и DefaultListCellRenderer, расширяющими класс JLabel. Именно потому, что выводом элементов фактически занимается класс JLabel, можно использовать в элементах списка текст или изображение. Интересный эффект получится, если смешать в одном списке типа JComboBox и текст, и изображения. Класс BasicComboBoxRenderer попытается вывести их вместе. Список типа JList, в котором текст перемежается изображениями, будет выведен правильно. Все дело в разной реализации интерфейса ListCellRenderer. Вот фрагмент реализации:

public class DefaultListCellRenderer extends JLabel implements ListCellRenderer, Serializable{

public Component getListCellRendererComponent( JList list, Object value, int index, boolean isSelected, boolean cellHasFocus){

setComponentOrientation(list.getComponentOrientation());

if (isSelected){

setBackground(list.getSelectionBackground()); setForeground(list.getSelectionForeground());

}else{

setBackground(list.getBackground()); setForeground(list.getForeground());

}

if (value instanceof Icon){ seticon((Icon)value);

setText("");

}else{

seticon(null);

setText((value == null) ? "" : value.toString());

}

setEnabled(list.isEnabled()); setFont(list.getFont()); setBorder((cellHasFocus) ?

UIManager.getBorder("List.focusCellHighlightBorder”) : noFocusBorder);

return this;

}

}

Как видно из этого фрагмента, в каждый формирующийся компонент — один элемент списка JList — может быть помещено либо изображение типа Icon, либо текст типа String. Всякий другой объект будет преобразован в строку его методом toString (), в том числе и объект класса JLabel. Легко изменить эту реализацию, убрав условие if(value instanceof Icon) из приведенного фрагмента и применив унаследованные от класса JLabel методы

setText(((JLabel)value).getText()); seticon(((JLabel)value).geticon());

После этого элементами списка могут служить объекты класса JLabel. Но это еще не все. Метод getSelectedValue () по-прежнему будет возвращать строку, выдаваемую методом JLabel. toString (), а не ссылку на объект. Значит, надо еще расширить класс JLabel, переписав метод toString ( ).

Итак, если разработчику нужно создать список, содержащий объекты других типов, отличных от String и Icon, то он должен написать класс, экземпляры которого будут служить элементами списка. В данном классе следует переопределить, кроме методов getXxx()/setXxx(), метод toString(), а при необходимости и метод paint (). Экземпляры этого класса записываются в конструктор JList(Object[]) и передаются методу getListCellRendererComponent () как параметр value.

Потом следует написать свою реализацию интерфейса ListCellRenderer. Обычно она расширяет класс JLabel или JPanel.

Упражнение

2. Перепишите листинг 10.2 с использованием компонентов Swing.

Счетчик JSpinner

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

текущее значение — 0, следующее — 1, предыдущее--1, и так можно перебирать все

целые числа.

Для создания более сложного счетчика конструктором JSpinner(SpinnerModel) придется сначала определять модель данных. Она описана интерфейсом SpinnerModel, частично реализована абстрактным классом AbstractSpinnerModel и полностью реализована в трех классах. Класс spinnerDateModel реализует модель, содержащую даты, класс SpinnerListModel — модель, содержащую коллекцию типа List, в частности, массив произвольных объектов типа object[]. Класс spinnerNumberModel содержит целые или вещественные числа или объекты класса Number.

Например, следующая строка:

JSpinner sp = new JSpinner(new SpinnerNumberModel(50, 0, 100, 5));

создает счетчик с текущим значением 50, диапазоном значений от 0 до 100 и шагом изменения значений 5. В поле можно ввести любое значение из указанного диапазона, например 47, тогда предыдущее значение будет равно 42, а следующее — 52.

С помощью класса SpinnerNumberModel можно создать еще модель с вещественными числами конструктором

SpinnerNumberModel(double current, double min, double max, double step);

и числовую модель общего вида конструктором

SpinnerNumberModel(Number current, Comparable min, Comparable max, Number step);

Значения min и max могут быть null, в таком случае нижняя или верхняя границы не существуют.

Текущее, предыдущее и следующее значение можно получить от счетчика JSpinner методами getValue (), getPreviousValue() и getNextValue() соответственно. Эти методы возвращают объект класса Object. Если значения выходят за заданные в конструкторе границы, то указанные методы возвращают null.

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

sp.addChangeListener(this);

// . . . .

public void stateChanged(ChangeEvent e){ comp.setValue((int)sp.getValue());

}

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

Конструктор

SpinnerDateModel(Date value, Comparable first,

Comparable last, Date step);

задает произвольную текущую дату value, диапазон значений дат от first до last и шаг step. Если одно или оба значения диапазона равны null, то соответствующая граница отсутствует. Шаг step определяет также и форму представления даты и может принимать значения одной из констант: era, year, month, week_of_year, week_of_month, DAY_OF_MONTH, DAY_OF_YEAR, DAY_OF_WEEK, DAY_OF_WEEK_IN_MONTH, AM_PM, HOUR, HOUR_OF_DAY, MINUTE, SECOND, MILLISECOND класса Calendar.

Более широкие возможности предоставляет третья модель данных класса —

SpinnerListModel. В конструкторе SpinnerListModel(Object[] ) этого класса можно задать массив произвольных объектов, например:

String[] data = {"Дворник", "Уборщица", "Программист", "Сторож"};

SpinnerListModel model = new SpinnerListModel(data);

JSpinner emp = new JSpinner(model);

В другом конструкторе, SpinnerListModel(List), задается экземпляр коллекции, реализующей интерфейс List, например экземпляр класса Vector.

Хотя в счетчик можно заложить любые объекты, в поле будет показана только строка, полученная методом toString () текущего объекта. Это происходит потому, что редактор по умолчанию, заложенный в класс JSpinner, — это экземпляр класса

JFormattedTextField. Определяет его вложенный в JSpinner класс DefaultEditor и его подклассы DateEditor, ListEditor и NumberEditor.

Полосы прокрутки JScrollBar

Полосы прокрутки используются многими компонентами и контейнерами Swing. В массе случаев достаточно поместить компонент на панель типа JScrollPane, как это сделано в листинге 11.3, чтобы обеспечить прокрутку содержимого компонента.

Полосы прокрутки определяются четырьмя числами-свойствами, хранящимися в модели данных. Это наименьшее значение полосы minimum, наибольшее значение maximum, текущее значение value и шаг изменения extent. От последнего числа зависит размер видимой области компонента, связанного с полосой прокрутки, и длина ползунка на полосе прокрутки. Действия с этими числами описаны интерфейсом BoundedRangeModel. При всяком изменении данных чисел происходит событие ChangeEvent. Класс JScrollBar использует в качестве модели данных реализацию DefaultBoundedRangeModel этого интерфейса.

Полосы прокрутки создаются конструктором

JScrollBar(int orientation, int value, int extent, int min, int max);

или конструктором JScrollBar(int orientation), устанавливающим значения min = 0, max = 100, value = 0, extent = 10. Вертикальная или горизонтальная ориентация задается константами vertical или horizontal.

Все значения можно потом изменить методами setMinimum(int), setMaximum (int), setValue(int) и setExtent(int).

Текущее значение возвращается методом getValue(). Метод getUnitIncrement(int) возвращает величину перемещения на одну единицу вверх, если параметр этого метода равен —1, или вниз, если параметр равен 1. Эта величина устанавливается равной 1 при создании полосы и может быть изменена методом setUnitincrement(int). Аналогично метод getBlockincrement (int) возвращает величину перемещения вверх или вниз на один блок. Размер блока вначале равен величине extent, затем ее можно изменить методом

setBlockIncrement(int).

Полоса прокрутки реагирует на событие AdjustmentEvent, происходящее при каждом изменении ее модели данных.

Ползунок JSlider

Ползунок представляет собой линейку с указателем, которым можно установить какое-то значение value из диапазона min-max. Внутренне ползунок устроен так же, как и полоса прокрутки.

Компонент JSlider тоже использует модель данных класса DefaultBoundedRangeModel с наименьшим, наибольшим и текущим значениями, а также шагом изменения. Впрочем, можно применить другую модель, задав ее в конструкторе JSlider(BoundedRangeModel) или установив методом setModel(BoundedRangeModel) .

Основной конструктор:

JSlider(int orientation, int min, int max, int value);

В других конструкторах отсутствует тот или иной параметр, при этом устанавливается горизонтальный ползунок со значениями min = 0, max = 100, value = (min + max)/2.

Рядом с линейкой ползунка можно разметить шкалу со штрихами, отстоящими друг от друга на расстояние, устанавливаемое методом setMajorTickSpacing(int). Вначале это расстояние равно нулю. После определения расстояния шкала задается методом setPaintTicks(true) . К штрихам можно добавить числовые значения методом setPaintLabels (true). Между штрихами допускается размещение более мелких штрихов методом setMinorTickSpacing ( int). Если применить метод setSnapToTicks (true), то движок ползунка будет останавливаться только против штрихов.

Основную линейку ползунка можно убрать методом setPaintTrack(false), оставив только шкалу.

Числовые значения в шкале ставятся против каждого штриха. Методом createStandardLabels ( int incr, int start) можно изменить это правило, задав другой шаг расстановки чисел incr на шкале и другой начальный отсчет start. Затем этот шаг надо установить на шкале методом setLabelTable(Dictionary). Все это удобно делать вместе, например после определений:

JSlider sl = new JSlider();

sl.setMaj orTickSpacing(10); sl.setMinorTickSpacing(5); sl.setPaintTicks(true); sl.setPaintLabels(true);

sl.setLabelTable(sl.createStandardLabels(20, 28));

получим отмеченные значения 28, 48, 68, 88, как показано на рис. 11.3.

Метод setLabelTable(Dictionary) позволяет сделать и более сложные изменения, установив в качестве меток не только числа, но и какие-то другие значения словаря типа

Di ctionary.

Внешний вид ползунка определяется абстрактным классом sliderUi. У него два расширения — классы BasicSliderUi и MultiSliderUi. На рис. 11.3 ползунок нарисован расширением класса BasicSliderUI — классом MetalSliderUI. При желании можно создать свой класс-рисовальщик, расширив один из этих классов и установив новый класс методом

setUI(SliderUi).

При перемещении движка в ползунке происходит событие ChangeEvent. В процессе обработки этого события можно получить значение ползунка методом getValue ( ).

Упражнение

3. Перепишите листинг 10.4, заменив полосы прокрутки ползунками Swing.

Индикатор JProgressBar

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

JProgressBar(int orientation, int min, int max);

задаются наименьшее min и наибольшее max значения этого числа. В других конструкторах опущены некоторые из указанных параметров. При этом ориентация считается горизонтальной, min = 0, max = 100.

По мере выполнения процесса он должен передавать степень своего выполнения в индикатор методом setvalue (int). Это значение немедленно отражается в индикаторе. После обращения к методу setStringPainted(true) в окне индикатора появится еще число — процент выполнения процесса.

Если время выполнения процесса, связанного с индикатором, не определено, то можно перевести индикатор в неопределенный режим (indeterminate mode). Это делается методом setindeterminate(true). В этом режиме индикатор мигает, показывая, что процесс выполняется. Когда окончание процесса определится, надо занести наибольшее значение процесса в индикатор методом setMaximum(int), текущее значение методом setValue (int) и перевести индикатор в обычный режим методом setindeterminate ( false).

Внешний вид индикатора описывается абстрактным классом ProgressBarUI. У него два расширения — классы BasicProgressBarUI и MultiProgressBarUI. Стандартный вид Java L&F обеспечивается классом MetalProgressBarUi. При необходимости изменения внешнего вида индикатора следует расширить один из этих классов и установить новый вид методом setUI ( ProgressBarUI).

Индикатор может работать в отдельном окне, эту возможность предоставляет класс

ProgressMonitor.

Дерево объектов JTree

Дерево JTree располагает объекты в иерархическую структуру. Она создается только на экране, но не в оперативной памяти. На уровне 0 находится один корневой (root) объект, на уровнях 1, 2 и т. д. размещаются его потомки (child) — узловые (node) объекты, имеющие своих потомков и одного предка (parent). На самом нижнем уровне расположены листья (leaf). Это узлы, не имеющие потомков.

Для экономии ресурсов дерево не определяется рекурсивно, его узлы не являются ссылками типа JTree. Вместо этого узел описан интерфейсом TreeNode и его расширением — интерфейсом MutableTreeNode. Это расширение добавляет методы замены объекта, находящегося в узле, а также методы добавления и удаления потомков из узла. Оно реализовано классом DefaultMutableTreeNode из пакета javax.swing.tree.

Узел дерева JTree создается конструктором DefaultMutableTreeNode(Object), в котором задается ссылка на содержащийся в узле объект.

Каждый узел класса DefaultMutableTreeNode содержит ссылку на своего предка, которую можно получить методом getParent (). Если этот метод возвращает null, значит, узел корневой, но для такой проверки есть специальный логический метод isRoot ().

Узел хранит ссылки на потомков в структуре типа Vector, получить их можно многочисленными методами getXxx (). Метод getLevel () показывает уровень узла относительно корня, а метод getDepth () — количество уровней поддерева, начинающегося с данного узла. Метод insert (MutableTreeNode, int) добавляет к узлу нового потомка в позицию, указанную вторым параметром. Метод setUserObject(Object) меняет ссылку на объект, расположенную в узле.

Узлы дерева можно сделать редактируемыми методом setEditable(true). Редактор должен реализовать методы интерфейса TreeCellEditor. По умолчанию используется реализация DefaultTreeCellEditor, открывающая для редактирования окно класса JTreeField.

Дерево класса JTree создается одним из семи конструкторов. Проще всего воспользоваться конструктором JTree(TreeNode), создающим корень дерева, а затем создавать и добавлять к дереву новые узлы.

Например:

DefaultMutableTreeNode root = new DefaultMutableTreeNode("KopeHb");

JTree tr = new JTree(root);

DefaultMutableTreeNode subtreel = new DefaultMutableTreeNode("Y3en 1"); root.add(subtree1);

subtree1.add(new DefaultMutableTreeNode('^HCT 2a"));

DefaultMutableTreeNode subtree2 = new DefaultMutableTreeNode("Y3en 2"); subtree1.add(subtree2);

subtree2.add(new DefaultMutableTreeNodeCVHHCT 3a")); subtree2.add(new DefaultMutableTreeNodeCVHHCT 3b")); subtree2.add(new DefaultMutableTreeNodeCVHHCT 3c"));

subtree1.add(new DefaultMutableTreeNode(YnucT 2b"));

root.add(new DefaultMutableTreeNode('^HCT 1"));

// Рё С‚. Рґ....

Для простоты каждый узел в этом дереве содержит строку класса String. Полученное дерево показано на рис. 11.4.

Против каждого узла выводится содержимое его объекта, преобразованное методом

toString().

Второй способ — сформировать вектор узлов дерева и воспользоваться конструктором JTree (Vector). Поддеревья создаются вложенными векторами. Вот как будет создано предыдущее дерево:

Vector root = new Vector();

Vector subtree1 = new Vector(); root.add(subtree1);

subtreel.add("Лист 2a");

Vector subtree2 = new Vector();

subtree1.add(subtree2); subtree2.add("Лист 3a"); subtree2.add("Лист 3b"); subtree2.add("Лист 3c"); subtree1.add('Vn^cT 2b");

root.add('^cT 1");

JTree tr = new JTree(root);

Недостаток этого метода в том, что у дерева, построенного с помощью вектора, нет корневого узла. Кроме того, в обоих вариантах узлы оказываются неподписанными, на экран выводится содержимое узлов в виде строки.

Второй недостаток можно устранить использованием конструктора JTree(Hashtable), аргумент которого — хеш-таблица. Вот как будет создано предыдущее дерево этим способом:

Hashtable root = new Hashtable();

Hashtable subtree1 = new Hashtable();

root.put("РЈР·eР» 1", subtreel);

Hashtable subtree2 = new Hashtable(); subtree1.put("Лист 2a", new Integer(21)); subtree1.put(,,Узeл 2", subtree2); subtree2.put("Лист 3a", new Integer(31)); subtree2.put("Лист 3b", new Integer(32)); subtree2.put("Лист 3c", new Integer(33)); subtree1.put("Лист 2b", new Integer(22));

root.put("Лист 1", new Integer(1));

JTree tr = new JTree(root);

Из каждой пары "ключ — значение", хранящейся в хеш-таблице, ключ выводится на экран в виде строки. У этого дерева тоже нет корня. Кроме того, его узлы выводятся не в том порядке, в котором помещаются в хеш-таблицу, т. к. она "перемешивает" свои данные.

Дерево с большим числом узлов удобно поместить на панель типа JScrollPane и указать число строк, помещающихся в окне, методом setVisibleRowCount(int), например:

JTree tr = new JTree(root);

JScrollPane sp = new JScrollPane(tr); tr.setVisibleRowCount(8);

В дереве можно выделить один или несколько узлов. Все узлы дерева пронумерованы сверху вниз, начиная от корневого узла, имеющего номер 0. Метод getSelectionRows ( ) возвращает массив типа int [ ] номеров выделенных узлов. Говоря точнее, нумерация узлов дерева описана интерфейсом RowMapper. В пакете javax.swing.tree есть абстрактный класс AbstractLayoutCache, реализующий этот интерфейс, и два его подкласса:

FixedHeightLayoutCache Рё VariableHeightLayoutCache.

Иногда удобнее получить путь к узлу в виде последовательности объектов, хранящихся в узлах, ведущих от корня к данному узлу. Такая последовательность хранится в классе TreePath. Метод getSelectionPath() возвращает экземпляр этого класса, метод getSelectionPaths () возвращает массив таких экземпляров для всех выделенных узлов. Есть и другие аналогичные методы получения экземпляров класса TreePath для различных узлов дерева.

Получив экземпляр класса TreePath, можно выбрать из него массив типа Object[] объектов, содержащихся в узлах, методом getPath(). Первый элемент этого массива всегда содержит объект, хранящийся в корне. Другие методы класса TreePath позволяют получить отдельные элементы этого массива.

Вся информация о выделенных элементах дерева находится в модели выбора, описанной интерфейсом TreeSelectionModel и реализованной классом DefaultTreeSelectionModel. Данный класс хранит массив типа TreePath [ ] путей к выделенным узлам и методы работы с этим массивом. Он предлагает три готовые модели выбора: выбор только одного узла дерева single_tree_selection, выбор диапазона узлов contiguous_tree_selection и выбор нескольких диапазонов discontiguous_tree_selection. Последний выбор принимается по умолчанию. Изменить модель выбора в дереве tr можно так:

tr.getSelectionModel().setSelectionMode(

TreeSelectionModel.SINGLE_TREE_SELECTION);

Модель выбора реагирует на событие класса TreeSelectionEvent, происходящее при всяком новом выборе узлов. В отличие от большинства классов событий, класс TreeSelectionEvent содержит несколько полезных при обработке события методов, например метод getPaths ( ) выдает массив типа TreePath [ ].

Вся информация об узлах дерева хранится в модели данных, описанной в интерфейсе TreeModel. Этот интерфейс не описывает класс узлов дерева. Узел может быть экземпляром любого класса. Но реализация DefaultTreeModel, принятая в классе JTree по умолчанию, уже требует, чтобы узел имел интерфейс TreeNode.

Модель данных реагирует на событие класса TreeModelEvent, происходящее при изменении узлов дерева. Этот класс события позволяет получить полезные данные о дереве, в частности, метод getTreePath() возвращает в виде объекта класса TreePath путь к предку тех узлов, которые были изменены, добавлены или удалены.

Подобно классу JList дерево типа JTree делегирует визуализацию классу-представителю, реализующему интерфейс TreeCellRenderer. Интерфейс описывает один метод:

Component getTreeCellRendererComponent(JTree tree, Object value, boolean selected, boolean expanded, boolean leaf, int row, boolean hasFocus);

Как видно из этого описания, изображение узла value дерева tree может меняться в зависимости от его порядкового номера в дереве row и от того, выбран ли этот узел selected, раскрыта ли соответствующая ветвь дерева expanded, является ли узел листом leaf и имеет ли узел фокус hasFocus.

Данный интерфейс реализован классом DefaultTreeCellRenderer, добавляющим массу свойств и методов и расширяющим класс JLabel. Последнее свойство позволяет вывести на экран различные значки для узлов и листьев, открытых и закрытых ветвей дерева.

В состав Java SE JDK входит пример построения дерева шрифтов, расположенный в каталоге $JAVA_HOME/demo/jfc/SampleTree/. В нем показано, как можно изменить стандартную визуализацию дерева.

Построение меню средствами Swing

Все компоненты, составляющие меню в библиотеке Swing: строка меню, пункты меню, всплывающее меню, имеют один и тот же тип, описанный интерфейсом MenuElement. Это позволяет объединять элементы какого-либо подменю или все меню, находящиеся в линейке меню, в массив с помощью метода getSubElements() и рассматривать их как одно целое.

Для создания системы меню сначала следует создать строку меню и установить ее в контейнер типа JFrame, JApplet, JDialog методом setJMenuBar(JMenuBar). Этот метод располагает строку меню горизонтально ниже строки заголовка окна.

Строка меню JMenuBar

Строка меню создается единственным конструктором класса JMenuBar(). Полученная строка не содержит ни одного меню, их надо добавлять методом add(JMenu) по мере создания. Добавляемые меню будут располагаться слева направо в порядке обращения к методам add (JMenu). В некоторых графических системах меню Справка (Help) располагается справа. Чтобы учесть эту особенность, в класс JMenuBar включен специальный метод setHelpMenu (JMenu). Впрочем, этот метод реализован далеко не во всех выпусках JDK.

Начнем создавать примерное меню:

JFrame f = new JFrame("npnMep системы меню");

JMenuBar mb = new JMenuBar()); f.setJMenuBar(mb);

JMenu file = new JMenu("0aRn"));

JMenu edit = new JMenu("npaBKa"));

JMenu view = new JMenu("BHJ"));

JMenu help = new JMenu("CnpaBKa"));

mb.add(file); mb.add(edit); mb.add(view); mb.add(help);

Меню JMenu

Каждое меню по существу представляет собой два компонента: "кнопку" с текстом и всплывающее меню типа JPopupMenu, появляющееся при щелчке кнопкой мыши по этой "кнопке". Как видно из рис. 11.1, меню JMenu относится к типу кнопок, расширяющих класс AbstractButton. Кроме того, класс JMenu непосредственно расширяет класс пункта меню JMenultem. Следовательно, объект класса JMenu может служить пунктом какого-то другого меню, образуя таким образом подменю.

Меню создается конструктором JMenu(String). Второй конструктор JMenu (String, boolean) создает плавающее (tear-off) меню, если второй параметр равен true. Это возможно не во всех графических системах.

Вновь созданное меню не содержит ни одного пункта. Пункты меню добавляются один за другим методом add(JMenuitem) или методом add(string). Интересно, что эти методы возвращают ссылку на объект класса JMenultem, а второй метод сам создает такой объект. Еще один метод, add(Component), добавляет к меню произвольный компонент. Это означает, что пунктом меню может служить любой компонент, но для встраивания в систему меню он должен реализовать интерфейс MenuElement. Например, иногда пунктом меню служит раскрывающийся список JComboBox. Но чаще среди пунктов меню встречаются экземпляры подклассов класса JMenultem: подменю — объекты класса JMenu, кнопки выбора класса JCheckBoxMenuitem и радиокнопки класса

JRadioButtonMenultem.

В меню можно отделить одну группу пунктов от другой горизонтальной чертой с помощью метода addSeparator( ).

Пункты меню, включая разделительную черту, нумеруются сверху вниз, начиная от нуля. Методы insert(JMenuItem, int), insert(String, int) и add(Component, int) позволяют вставить новый пункт в указанную вторым параметром позицию, а метод insertSeparator (int) вставляет горизонтальную разделительную черту в указанную позицию.

Методы remove (Component), remove (int), remove (JMenultem) и removeAll ( ) удаляют пункты из меню. В сочетании с методами add() и insert () они позволяют динамически перестроить меню при изменении содержимого окна.

Меню, как и всякой кнопке, можно назначить командную клавишу методом setMnemonic (int). Добавим командные клавиши-акселераторы к меню нашего примера:

file.setMnemonic(KeyEvent.VK A); edit.setMnemonic(KeyEvent.VK G); view.setMnemonic(KeyEvent.VK D); help.setMnemonic(KeyEvent.VK C);

Меню реагирует на событие класса MenuEvent, происходящее при раскрытии, выборе пунктов и закрытии меню.

Пункт меню JMenuItem

Класс JMenultem расширяет класс AbstractButton и поэтому во многом наследует поведение кнопки. При создании пункта меню в нем можно задать текст

JMenultem (String), изображение JMenultem(Icon) или сразу и то и другое конструктором JMenultem(String, Icon). Взаимное положение текста и изображения можно отрегулировать так же, как это делалось для кнопки.

Добавим пункты и разделительную черту к меню Файл нашего примера. Забегая вперед, добавим и методы обработки событий. Объяснение этих методов будет дано в главе 15.

JMenu nw = new JMenu("Создать");

file.add(nw); // Добавляем как подменю

nw.addC'OaRn"); // Пункты подменю

nw.add("Сообщение"); nw.add("Образ");

JMenultem open = file.add("OTKpbiTb...");

JMenultem close = file.add("3aKpbiTb"); file.addSeparator();

// Другой способ:

JMenultem exit = new JMenuItem("Выход"); file.add(exit);

// Обрабатываем события:

open.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

JFileChooser fch = new JFileChooser(); fch.showOpenDialog(null);

}

});

exit.addActionListener(new ActionListener(){ public void actionPerformed(ActionEvent e){

System.exit(0);

}

});

При создании пункта меню, содержащего текст, можно сразу же задать командную клавишу-акселератор, используя конструктор JMenuitem(string, int). Потом это сделать не удастся, поскольку метод setMnemonic(int) не реализован в классе JMenultem, точнее говоря, он переопределен так, что только выбрасывает исключение. Назначать командную клавишу следует специальным методом setAccelerator(KeyStroke), при этом в пункт меню добавляется описание командной клавиши, например Ctrl+O. Добавим эту командную клавишу к пункту Открыть нашего меню Файл:

open.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK O, Event.CTRL MASK));

Класс JMenultem отслеживает, кроме унаследованных событий ChangeEvent, ActionEvent, itemEvent, еще и события классов MenuKeyEvent, происходящие при нажатии и отпускании клавиш, и MenuDragMouseEvent, происходящие при прохождении курсора мыши над пунктом меню.

Пункт меню JCheckBoxMenuItem

Вставить в меню кнопки выбора удобнее всего с помощью специально включенного в библиотеку Swing класса JCheckBoxMenuItem. Этот класс наследует все свойства своего суперкласса JMenultem и добавляет логический метод getstate (), позволяющий отследить состояние кнопки. Впрочем, можно пользоваться и унаследованным методом

isSelected().

Добавим кнопки выбора к меню Вид нашего примера:

JCheckBoxMenuItem cbml = new JCheckBoxMenuItem("Текст");

JCheckBoxMenuItem cbm2 = new JCheckBoxMenuItem("Знaчки");

JCheckBoxMenuItem cbm3 = new JCheckBoxMenuItem("Р РёСЃСѓРЅРєРё");

view.add(cbml); view.add(cbm2); view.add(cbm3);

view.addSeparator();

cbm1.addItemListener(new ItemListener(){ public void itemStateChanged(ItemEvent e){

if (e.getStateChange() == ItemEvent.SELECTED) ch.setText(txt); else ch.setText("");

}

});

Пункт меню JRadioButtonMenuItem

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

Добавим группу радиокнопок к меню Вид нашего примера:

JRadioButtonMenultem rbml =

new JRadioButtonMenuItem("Большой");

JRadioButtonMenultem rbm2 =

new JRadioButtonMenuItem("Средний");

JRadioButtonMenultem rbm3 =

new JRadioButtonMenuItem("Мaлый");

view.add(rbml);view.add(rbm2); view.add(rbm3);

ButtonGroup bg = new ButtonGroup();

bg.add(rbml); bg.add(rbm2); bg.add(rbm3);

Всплывающее меню JPopupMenu

Всплывающее меню (pop-up menu) используется обычно как контекстное меню. Оно появляется в MS Windows и Java L&F при отпускании правой кнопки мыши. В некоторых графических системах для появления контекстного меню надо нажать

среднюю кнопку мыши. Контекстное меню обычно содержит перечень действий, доступных в компоненте, над которым находится курсор мыши, при данном положении курсора мыши. Поэтому контекстное меню не привязывается к строке меню или другому меню, а соотнесено с одним или несколькими компонентами. Оно добавляется к компонентам при обработке событий мыши класса MouseEvent.

Для того чтобы отследить событие, при наступлении которого в данной графической системе следует вызвать всплывающее меню, в классе MouseEvent есть логический метод isPopupTrigger (). К этому методу следует обращаться при всяком событии мыши. Когда метод isPopupTrigger ()вернет true, показав тем самым, что надо вызывать всплывающее меню, следует обратиться к методу show(Component, int, int). В нем первый параметр — это компонент, над которым появится окно всплывающего меню, второй и третий параметры — координаты курсора мыши в системе координат этого компонента. Вот стандартная конструкция, в которой popup — это экземпляр класса JPopupMenu:

public void processMouseEvent(MouseEvent e){ if (e.isPopupTrigger())

popup.show(e.getComponent(), e.getX(), e.getY()); else super.processMouseEvent(e);

}

При этом следует убедиться, что компонент, для которого вызывается всплывающее меню и в котором записан приведенный ранее метод processMouseEvent(), отслеживает события мыши, т. е. к нему присоединен методом addMouseListener( ) хотя бы один слушатель или в нем есть обращение к методу enableEvents (AWTEvent. MOUSE_EVENT_MASK).

Действия со всплывающим меню похожи на действия с обычным меню. Сначала создается пустое меню конструктором JPopupMenu ( ) или JPopupMenu (String). Строка, записанная во втором конструкторе, должна быть заголовком меню, но она отображается на экран не всеми графическими системами. Эту строку можно добавить потом методом setLabel (String). Затем в созданное всплывающее меню методами add(Action), add(JMenultem) или add(String) добавляются пункты меню. Методы insert ( ) и remove() позволяют динамически перестроить меню.

Всплывающее меню перед своим появлением на экране, исчезновением с экрана и перед уничтожением вызывает событие класса PopupMenuEvent.

Панель выбора цвета JColorChooser

Многие приложения, связанные с рисованием, обработкой текстов и изображений, требуют задания определенных цветов. Библиотека Swing предлагает простой класс JColorChooser, предоставляющий панель с палитрами цветов в моделях RGB и HSB. Есть три способа использования этого класса.

Самый простой способ — создать диалоговое окно, содержащее панель выбора цветов статическим методом showDialog(Component, String, Color). Первый параметр этого метода задает окно верхнего уровня, в которое помещается панель. Значение null указывает, что окном будет служить экземпляр класса Frame, располагающийся в центре экрана. Второй параметр дает заголовок этому окну, а третий параметр задает начальный цвет, причем null устанавливает белый цвет. Например:

Color c = JColorChooser.showDialog(null, "Цвет", null);

На экране появляется модальное диалоговое окно с цветовой палитрой, ползунками, задающими интенсивность цвета, и кнопками OK, Cancel и Reset. Метод showDialog () возвращает выбранный цвет после щелчка по кнопке OK и null, если щелчок был сделан по кнопке Cancel. После этого диалоговое окно удаляется с экрана, но не уничтожается. Оно запоминает выбранный цвет и при следующем выборе этот цвет можно восстановить щелчком по кнопке Reset. При первом появлении окна на экране щелчок по кнопке Reset возвращает начальный цвет, заданный третьим параметром метода.

Более гибкий и сложный способ — создать диалоговое окно с панелью цветов статическим методом createDialog(Component, String, boolean, JColorChooser, ActionListener, ActionListener). Этот метод, кроме окна верхнего уровня и его заголовка, позволяет задать третьим параметром модальность диалогового окна. Четвертый параметр обеспечивает выбор цвета не только экземпляра класса JColorChooser, но и любого расширения этого класса. Пятый и шестой параметры позволяют задать нестандартную обработку щелчков по кнопкам OK и Cancel соответственно. При этом выбранный цвет можно получить методом getColor (). Например:

JDialog d = JColorChooser.createDialog( new JFrame(), "Выбор цвета", false, cc = new JColorChooser(), new OkColor(), new CancelColor());

d.setVisible(true);

class OkColor implements ActionListener{

public void actionPerformed(ActionEvent e){ comp.setColor(cc.getColor());

}

}

class CancelColor implements ActionListener{

public void actionPerformed(ActionEvent e){ comp.setColor(defColor) ;

}

}

Третий способ — если нет необходимости создавать отдельное диалоговое окно, а нужна только панель выбора цветов, то можно воспользоваться конструкто-ром JColorChooser (Color), в котором задается начальный цвет, или конструктором JColorChooser (), устанавливающим белый цвет в качестве исходного.

В этом случае определять момент окончания выбора цвета придется самостоятельно. Класс JColorChooser отслеживает только событие PropertyChangeEvent изменения свойств Java Bean, которое можно обработать, присоединив обработчик унаследованным от класса JComponent методом

addPropertyChangeListener(PropertyChangeListener);

Чтобы отследить выбор цвета, можно также обратиться к модели данных, все интерфейсы и классы которой собраны в пакет j avax. swing. colorchooser.

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

getSelectionModel ( ). Эта модель отслеживает событие ChangeEvent.

При необходимости изменения модели данных можно сделать другую реализацию интерфейса ColorSelectionModel и установить ее при создании объекта конструктором

JColorChooser(ColorSelectionModel).

Упражнение

4. Перепишите "рисовалку" листинга 10.9 или листинга 10.10 с использованием компонентов Swing.

Окно выбора файла JFileChooser

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

Для создания экземпляра окна выбора файла есть несколько конструкторов. Конструктор JFileChooser (File) или JFileChooser(String) создает окно, в котором показан каталог с указанным файлом. Конструктор по умолчанию JFileChooser() открывает окно с начальным каталогом пользователя. Он соответствует JFileChooser(null). Еще в трех конструкторах задается объект класса FileSystemView, позволяющий получить различные атрибуты файла.

По умолчанию окно показывает только файлы (режим files_only). Перед выводом окна на экран можно установить режим показа только каталогов directories_only или файлов и каталогов files_and_directories. Эти режимы устанавливаются методом

setFileSelectionMode(int).

По умолчанию окно не отображает скрытые (hidden) файлы. Чтобы задать их показ, надо обратиться к методу setFileHidingEnabled (false).

По умолчанию в окне можно отметить один файл. Возможность выбора нескольких файлов задается методом setMultiSelectionEnabled(true).

Фильтр файлов FileFilter

По умолчанию окно показывает все файлы в выбранном каталоге. Установив фильтр, можно ограничить отображение отдельными файлами. Для этого надо расширить абстрактный класс FileFilter из пакета javax.swing.filechooser (не перепутайте с интерфейсом FileFilter из пакета java.io) и установить полученный фильтр в окне выбора файла методом addChoosableFileFilter (FileFilter). Этот метод можно применить несколько раз с разными параметрами, определив несколько фильтров в одном окне.

Класс FileFilter содержит всего два абстрактных метода. Логический метод accept (File) возвращает true, если его параметр следует показать в окне. Метод getDescription() возвращает строку описания данного фильтра, которая будет отображена в поле Тип файлов (Files of type) окна выбора.

Вот пример фильтра, отбирающего только файлы с расширением java. Вид окна открытия файла с соответствующим фильтром показан на рис. 11.5.

class JavaFileFilter extends javax.swing.filechooser.FileFilter{ public boolean accept(File f){ if (f != null){

String name = f.getName();

int i = name.lastIndexOf(’.’);

if (i>0 && i < name.length() — 1)

return name.substring(i + 1).equalsIgnoreCase("j ava");

}

return false;

}

public String getDescription(){ return "Файлы Java";

}

}

После создания экземпляра окна выбора и установки режимов и фильтров окно можно показать на экране как модальное окно открытия файла методом showOpenDialog(Component), как модальное окно сохранения файла showSaveDialog(Component) или как модальное окно произвольного выбора showDialog(Component, string). В последнем методе второй параметр задает произвольную надпись вместо надписи Открыть (Open) или Сохранить как (Save as). Первый параметр этих методов задает компонент, от которого зависит и над контейнером которого будет расположено окно выбора файла. Чаще всего это Frame, который можно задать просто параметром null.

Итак, создать и показать окно выбора файла очень просто:

JFileChooser fch = new JFileChooser();

fch.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES); fch.setFileHidingEnabled(false);

fch.setMultiSelectionEnabled(true); fch.addChoosableFileFilter(new JavaFileFilter()); fch.addChoosableFileFilter(new AnotherFileFilter());

switch (fch.showDialog(null, "Открыгть")) { case JFileChooser.APPROVE OPTION:

File selectedFile = fch.getSelectedFile();

File directory = fch.getCurrentDirectory(); break;

case JFileChooser.CANCEL_OPTION: break;

case JFileChooser.ERROR OPTION:

System.err.println("Error"); break;

}

Как получить выбранный файл

Как видно из этого примера, методы вида showXxxDialog () возвращают целое число — одну из трех констант, соответствующих выбору файла и щелчку по кнопке Открыть (Open) или Сохранить (Save) — константа approve_option, щелчку по кнопке Отмена (Cancel) — константа cancel_option или появлению ошибки — константа error_option.

После того как пользователь отметил файл в окне выбора, этот файл можно получить методом getSelectedFile () в виде экземпляра класса File, как показано ранее. Если установлен режим выбора и файлов, и каталогов — files_and_directories, — то при выборе каталога этот метод возвращает null. Если же установлен режим выбора только каталогов directories_only, то возвращается каталог. Если задан выбор нескольких файлов, то их массив типа File[] можно получить методом getSelectedFiles(). Каталог, в котором находится выбранный файл, можно получить в виде экземпляра класса File методом getcurrentDirectory(), как показано ранее.

Итак, стандартная работа с окном выбора файлов выглядит следующим образом:

JFileChooser fch = new JFileChooser(); int state = fch.showOpenDialog(null);

File f = fch.getSelectedFile();

if (f != null && state == JFileChooser.APPROVE OPTION)

JOptionPane.showMessageDialog(null, f.getPath()); else if (state == JFileChooser.CANCEL OPTION)

JOptionPane.showMessageDialog(null, "Canceled");

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

Дополнительный компонент

Возможности окна выбора файла легко расширить, добавив в него произвольный компонент методом setAccessory(JComponent). Чаще всего добавляется небольшое окно предварительного просмотра отмеченного файла, хотя можно добавить что угодно, да-

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

class ImagePreviewer extends Jlabel implements PropertyChangeListener{

public ImagePreviewer(JFileChooser fch){ if (fch == null)

throw new IllegalArgumentException("fileChooser must be non-null"); fch.addPropertyChangeListener(this);

}

public void loadImageFromFile(File f){

Icon icon = null; if (f != null){

ImageIcon im = new ImageIcon(f.getPath());

Dimension size = getSize();

if (im.getIconWidth() != size.width)

icon = new ImageIcon(im.getImage().getScaledInstance(

size.width, size.height, Image.SCALE DEFAULT)); else icon = im;

}

setIcon(icon);

}

public void propertyChange(PropertyChangeEvent e){

String prop = e.getPropertyName();

if (prop.equals(JFileChooser.SELECTED_FILE_CHANGED_PROPERTY)){

File f = (File)e.getNewValue(); if (isShowing()){

loadlmageFromFile(f); repaint();

}

}

}

}

После определения объекта класса JFileChooser, но до его вывода на экран, присоединяем этот компонент:

JFileChooser fch = new JFileChooser();

ImagePreviewer ip = new ImagePreviewer(fch); ip.setPreferredSize(new Dimension(200, 200)); fch.setAccessory(ip);

Получившееся окно открытия файла показано на рис. 11.5.

Замена изображений

В окне выбора файла перед каталогами и файлами выводятся стандартные значки. Их можно заменить какими-то другими изображениями. Для этого надо расширить абстрактный класс FileView, переопределив пять его методов, и установить новые изобра-

жения методом setFileView(FileView). Например, выведем перед исходными файлами Java изображение дымящейся чашечки кофе:

class JavaFileView extends FileView{

public String getName(File f){

return null; // Оставляем системную реализацию

}

public String getDescription(File f){

String ext = getExtension(f); if (ext != null && ext.equals("java")) return "Исходным файл Java"; else return null;

}

public String getTypeDescription(File f){ return getDescription(f);

}

Icon icon = new ImageIcon("javacup.gif");

public Icon getIcon(File f){

String ext = getExtension(f); if (ext != null && ext.equals("java")) return icon; return null;

}

public Boolean isTraversable(File f){

return null; // Оставляем системную реализацию

}

protected String getExtension(File f){ if (f != null){

String name = f.getName();

int i = name.lastIndexOf(’.’);

if (i > 0 && i < name.length() — 1)

return name.substring(i + 1).toLowerCase();

}

return null;

}

}

Теперь достаточно к описанию объекта fch класса JFileChooser добавить строку

fch.setFileView(new JavaFileView());

и стандартный значок перед исходными файлами Java с расширением java будет заменен изображением из файла javacup.gif, как показано на рис. 11.5.

Более содержательный пример создания окна выбора файла имеется в составе J2SE JDK в каталоге $JAVA_HOME/demo/jfc/FileChooserDemo/.

Окно выбора файлов чаще всего создается в отдельном диалоговом окне, но это обычный компонент Swing, и его можно поместить в контейнер. При этом можно убрать кнопки выбора и отмены выбора методом setControlButtonsAreShown(boolean).

Русификация Swing

Как видно из примеров этой главы, компоненты библиотеки Swing правильно отображают кириллицу по обычным правилам, изложенным в главе 5. Остается лишь русифицировать стандартные надписи, что видно на рис. 11.6. Для этого надо написать несколько файлов ресурсов (properties), которые, если они есть, просматриваются классами-рисовальщиками компонентов перед выводом на экран. Эти файлы уже написаны Сергеем Астаховым и лежат в файле swing_ru.jar, ссылку на который можно найти, например, по адресу . Достаточно поместить архив swing_ru.jar, не распаковывая, в каталог $JAVA_HOME/lib/ext/, и все надписи будут сделаны по-русски, как показано на рис. 11.6.

На том же сайте: , да и на других страницах Интернета находится статья Сергея Астахова "Русские буквы и не только...", в которой собрано все касающееся русификации Java. По всем вопросам, возникающим при работе с кириллицей, безусловно, нужно обращаться к этому ресурсу.

Вопросы для самопроверки

1. Чем отличаются компоненты Swing от компонентов AWT?

2. Какая конструктивная схема использована в компонентах Swing?

3. В каких случаях приходится изменять Модель компонента?

4. В каких случаях приходится изменять Вид компонента?

5. Какими компонентами Swing можно создать кнопку с двумя состояниями?

6. Какие компоненты Swing создают радиокнопки?

7. Как в Swing показать каталоги и имена файлов в виде дерева?

8. Можно ли средствами Swing создать всплывающее меню?

ГЛАВА 12