Текст книги "Графические интерфейсы пользователя Java"

Glass Pane

Здесь показан пример использования панели Glass Pane для рисования поверх компонентов, содержащихся в панели содержимого.

Пользовательская панель Glass Pane устанавливается для контейнера верхнего уровня методом setGlassPane.

Так как по умолчанию она невидима, для нее нужно вызвать метод setVisible (true).

Панель по умолчанию можно получить методом getGlassPane контейнера верхнего уровня.

Слоистая панель Layered Pane представляет собой контейнер с глубиной, так что перекрывающиеся компоненты могут отображаться один поверх другого.

Каждая корневая панель root pane контейнера верхнего уровня помещает панель меню и панель содержимого в экземпляр слоистой панели JLayeredPane.

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

Слоистая панель может использоваться для размещения компонентов один над другим по оси Z, создавая таким образом 3D эффект глубины.

Панель по умолчанию можно получить методом getLayeredPane контейнера верхнего уровня.

Установить пользовательскую панель для контейнера верхнего уровня можно методом setLayeredPane.

Компоненты добавляются в панель методом add, при этом указывается позиция на оси Z компонента.

По умолчанию слоистая панель не имеет менеджера компоновки, поэтому для размещения компонентов используется метод setBounds.

JInternalFrame

С помощью классов JInternalFrame и JDesktopPane можно создавать многооконные приложения, в которых программа имеет одну большую панель «рабочий стол», которая содержит все остальные окна.

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

Кроме того, минимизация панели рабочего стола скрывает все содержащиеся окна.

Класс JDesktopPane расширяет класс JLayeredPane специально для работы с внутренними окнами JInternalFrame.

Объект JDesktopPane представляет собой контейнер, используемый для создания интерфейса с несколькими документами или виртуального рабочего стола.

Вы создаете объекты JInternalFrame и добавляете их в объект JDesktopPane.

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

Каждое внутреннее окно JInternalFrame содержит корневую панель JRootPane.

При использовании внутренних окон вы должны установить их размер.

Если вы не установите размер внутреннего фрейма, он будет иметь нулевой размер и, следовательно, никогда не будет виден.

Вы можете установить размер, используя один из методов setSize, pack или setBounds.

Также вы должны установить местоположение внутреннего фрейма.

Если вы не установите местоположение внутреннего фрейма, он будет установлен в верхний левый угол контейнера.

Вы можете использовать метод setLocation или setBounds, чтобы указать верхнюю левую точку внутреннего фрейма относительно контейнера.

Диалоги для внутренних фреймов должны быть реализованы с использованием JOptionPane или JInternalFrame, а не JDialog, который является тяжеловесным контейнером.

По умолчанию внутренние фреймы невидимы, поэтому для их отображения нужно вызвать метод setVisible (true) или show.

При создании внутреннего фрейма нужно явно указывать, что он содержит кнопки Свернуть, Развернуть, Закрыть, и может изменять размеры.

JOptionPane

Хотя класс JDialog позволяет создавать любые диалоговые окна, в подавляющем большинстве случаев их назначение сводится к выводу сообщений, подтверждению или отмене каких-то действий и вводу данных.

Класс JOptionPane предоставляет большой набор статических методов для создания модальных диалоговых окон.

Класс JOptionPane не расширяет класс JDialog, а напрямую расширяет класс JComponent, и является скорее фабрикой для создания диалоговых окон, чем просто компонентом.

Класс JOptionPane предоставляет методы showMessageDialog с разными аргументами, создающие окна сообщений.

Методы showConfirmDialog, создающие окна подтверждения.

методы showInputDialog, создающие окна ввода.

И метод showOptionDialog, создающий диалоговое окно общего вида.

Эти методы создают диалоговые окна JDialog.

Есть еще другие методы вида showInternalXxxDialog, которые предназначены для создания диалоговых окон для внутренних фреймов JInternalFrame.

Метод showMessageDialog с помощью констант класса JOptionPane – INFORMATION_MESSAGE, WARNING_MESSAGE, ERROR_MESSAGE, QUESTION_MESSAGE и PLAIN_MESSAGE, позволяет с помощью иконки обозначить для пользователя тип сообщения.

Один из методов showMessageDialog позволяет добавить свою иконку в диалог.

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

В качестве сообщения может быть компонент класса Component и изображение типа Icon.

Все остальные объекты преобразуются в строку методом toString, строка помещается в созданный объект класса JLabel, который и выводится в окно сообщения.

Для ввода пользователем строки данных используется метод showInputDialog, который создает диалоговое окно с полем ввода и кнопками OK и Cancel.

После нажатия кнопки OK метод возвращает строку, введенную пользователем, которую затем можно использовать в приложении.

С помощью одного из методов showInputDialog, вместо поля ввода, можно показать пользователю список выбора.

Здесь мы сначала определяем массив выбора, который затем передаем в метод showInputDialog.

Метод showConfirmDialog создает окно подтверждения или отмены действий, которое содержит две или три кнопки: Yes, No, Cancel.

Это регулируется константами YES_NO_OPTION или YES_NO_CANCEL_OPTION параметра метода showConfirmDialog.

Метод возвращает одну из констант YES_OPTION, NO_OPTION, CANCEL_OPTION в зависимости от того, какая кнопка была нажата.

При закрытии окна без всякого выбора возвращается константа CLOSED_OPTION.

Метод showOptionDialog создает диалог, похожий на диалог метода showConfirmDialog.

Предпоследний параметр метода задает надписи на кнопках диалогового окна или графические компоненты, выводимые в окно вместо кнопок.

Последний параметр метода выделяет одну из кнопок или графических компонентов.

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

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

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

Вы можете определить шрифт и цвет текста компонента, вызвав методы setFont и setForeground компонента, соответственно.

Если вы хотите смешивать шрифты или цвета внутри текста, вы можете использовать HTML разметку.

Чтобы указать, что текст компонента имеет форматирование HTML, просто поместите тег <html> в начало текста, а затем используйте простую HTML разметку.

Диалоговые окна также можно создавать с помощью конструкторов класса JOptionPane и метода createDialog.

JWindow

Класс JWindow представляет простейшее окно верхнего уровня, которое может располагаться в любом месте экрана.

Класс JWindow расширяет класс Window библиотеки AWT и является тяжеловесным компонентом.

У этого окна нет рамки и строки заголовка с кнопками.

Оно не регистрируется у оконного менеджера операционной системы, следовательно, не перемещается по экрану и не изменяет свои размеры.

Чаще всего окно JWindow используют как splash окно, появляющееся на экране на время загрузки основного окна приложения.

Окно JWindow может быть связано с уже существующим, «родительским» фрейм окном.

Окно JWindow содержит непосредственно всего один компонент – корневую панель JRootPane, получить которую можно методом getRootPane.

Также с помощью методов getContentPane, getLayeredPane и getGlassPane можно получить доступ к панели содержимого, слоеной панели и к прозрачной панели.

По умолчанию для панели содержимого установлена компоновка BorderLayout.

На этом примере видно, что компонент JWindow не добавляется в родительский компонент JFrame, а создается как независимое окно.

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

И окно JWindow будет всегда располагается сверху родительского окна.

Event Dispatching Thread

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

Причина этого кроется в том, что интерфейс основан на событиях.

Нажатие клавиши, движение мыши, и так далее – всё это ни что иное как события.

Они помещаются в одну очередь и обрабатываются одним потоком – Event Dispatching Thread, сокращенно EDT.

И все эти события обрабатываются одним потоком – EDT.

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

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

В течение этого времени поток, в котором обрабатывалось нажатие кнопки, будет просто блокирован.

А в этом же потоке обрабатываются и события мыши – то есть нажать кнопку «Отмена» и прервать выполнение запроса не получится: сгенерированные события встанут в очередь и будут обработаны только после того, как EDT будет разблокирован.

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

Но тут возникает другая проблема.

Дело в том, что практически все компоненты Swing – НЕ потоко безопасны.

Что означает, что методы Swing компонентов должны вызываться в потоке EDT.

Следующий пример демонстрирует, когда код работает в потоке EDT.

Метод isEventDispatchThread класса SwingUtilities возвращает true, если текущий поток является потоком диспетчеризации событий AWT event dispatching thread.

Когда запускает метод main, текущий поток не является потоком EDT.

Когда выполняется обработчик событий нажатия кнопки, текущий поток является потоком EDT.

Таким образом, код в методе main создает графический интерфейс и отдельный поток EDT, в котором выполняются методы Swing компонентов.

И ваш метод main может быть занят другой задачей, такой как вычисление PI до 40 000 знаков после запятой.

И пользователю не нужно дождаться завершения метода main до того, как они смогут взаимодействовать с графическим интерфейсом.

Потому что библиотека AWT реализует свой собственный поток EDT для обработки взаимодействия с графическим интерфейсом.

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

AWT поток захватывает системное событие из очереди и определяет, что с ним делать.

Если он выглядит как щелчок поверх компонента, он вызывает обработчик щелчка мыши для этого компонента.

Этот компонент, в свою очередь, запускает свои события.

Например, если вы нажимаете на JButton, поток AWT передает щелчок мыши компоненту JButton, который интерпретирует его как «нажатие кнопки» и запускает собственное событие, которое будет передано в вызванный метод actionPerformed любого слушателя.

Поток AWT также обрабатывает перерисовку вашего графического интерфейса.

Каждый раз, когда вы вызываете repaint, в очередь событий помещается запрос «refresh».

Всякий раз, когда поток AWT видит запрос «refresh», он вызывает соответствующие методы для компоновки графического интерфейса и рисования любых компонентов, требующих рисования.

AWT-поток может фактически реализоваться несколькими потоками, которые координируют усилия, чтобы следить за щелчками мыши, нажатиями клавиш, запросами перерисовки и т. д.

Однако вы можете рассматривать это как один «поток AWT».

Компоненты AWT являются потокобезопасными, так как если вы вызываете метод setText компонента Label, он синхронизируется так, что отображаемый текст не может отображаться с частично старым значением и частично новым значением.

Однако компоненты Swing не являются потокобезопасными для большей эффективности.

Из-за этого вы должны убедиться, что любые изменения компонентов Swing, которые могут повлиять на их отображение, выполняются в потоке событий AWT EDT.

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

Этот поток EDT становится активным после реализации компонента, после вызова либо метода pack, либо метода show, либо setVisible (true).

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

И почти все вызовы реализованных компонентов должны выполняться в потоке EDT.

Потоко безопасными исключениями являются:

Некоторые методы класса JComponent: repaint, revalidate, invalidate.

Все методы addXXXListener и removeXXXListener.

Таким образом, метод main запускает первоначальный поток Initial thread.

Это поток, с которого начинается основная программа.

В этом потоке запускается поток EDT, Event Dispatch Thread.

Первоначальный поток заканчивается, когда завершается метод main, и единственный поток, который продолжается далее, – это поток EDT.

Графический интерфейс пользователя должен быть инициализирован в потоке EDT, хотя для простых программ это, как правило, необязательно, и часто это не делается.

Даже если вы не инициализировали графический интерфейс в потоке EDT, побочным эффектом вызова метода setVisible (true) является запуск потока EDT, который продолжает работать и отслеживать графический интерфейс.

Для выполнения кода в потоке EDT используются методы invokeAndWait и invokeLater класса EventQueue или класса SwingUtilities.

Разницы здесь нет, так как внутренне класс SwingUtilities вызывает соответствующий метод класса EventQueue.

Эти методы в качестве параметра принимают объект класса, реализующего интерфейс Runnable.

Объект класса, реализующего интерфейс Runnable, используется для переопределения метода run (), который вызывается потоком EventDispatchThread.

Вызов метода invokeAndWait является синхронным, т.е. не осуществляет возврат до тех пор, пока поток диспетчеризации событий не исполнит код, определенный в методе run.

Вызов метода invokeLater является асинхронным, то есть метод возвращает сразу.

Обычно, источником проблем является вызов слушателей.

Слушатели вызываются в потоке EDT, но пока слушатель занят, графический интерфейс замораживается, потому что поток EDT занят.

Решение состоит в том, чтобы запускать длительные действия слушателя в рабочем потоке Worker thread.

В этом примере, в обработчике событий кнопки, мы создаем поток для выполнения длительной операции.

После выполнения этой операции мы хотим обновить наш графический интерфейс пользователя.

Для этого мы вызываем метод invokeLater и уже в потоке EDT обновляем Swing компонент.

Не вызывайте метод invokeAndWait из потока событий EDT.

Если вы это сделаете, поток событий будет заблокирован навсегда, так как произойдет взаимная блокировка ожиданием.

Поток EDT будет сам ожидать своего завершения.

SwingWorker

Вместо низкоуровневого API Runnable, для выполнения длительных операций, можно использовать высокоуровневый API, представленный классом SwingWorker.

Сам SwingWorker является абстрактным классом.

Вы должны определить подкласс для создания объекта SwingWorker.

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

Переопределить метод doInBackground для запуска кода в рабочем или фоновом потоке.

Использовать метод get для получения чего-либо, вычисленного во время выполнения метода doInBackground.

Переопределить методы process и/или метод done для запуска кода в потоке событий EDT.

Вызвать метод execute для запуска рабочего потока.

В этом примере мы создаем и запускаем объект SwingWorker в обработчике событий кнопки.

В методе doInBackground объекта SwingWorker мы выполняем длительную операцию, из которой возвращаем строку.

В методе done, который выполняется в потоке событий EDT после завершения метода doInBackground, мы обновляем Swing компонент, используя полученную строку, которую мы получаем методом get.

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

Самым простым способом указания работы является установка курсора ожидания с использованием класса Cursor и метода setCursor, определенного компонентом.

В этом примере, перед запуском SwingWorker, мы устанавливаем курсор ожидания, и после завершения задачи, в методе done, мы возвращаем курсор в исходное состояние.

JProgressBar

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

Класс SwingWorker имеет встроенные связанные свойства progress и state.

Мы уже говорили о связанных свойствах в контексте компонентов JavaBeans.

Связанные свойства уведомляют слушателей, когда изменяется их значение.

Эти связанные свойства progress и state объекта SwingWorker могут быть использованы для взаимодействия рабочего потока с EDT потоком.

Связанное свойство progress представляет собой значение int, которое может варьироваться от 0 до 100.

Оно имеет защищенный метод setProgress и публичный метод getProgress.

Связанное свойство progress может быть использовано для обновления компонента JProgressBar из рабочего потока.

Связанное свойство state указывает фазу жизненного цикла объекта SwingWorker.

Связанное свойство state содержит константы PENDING (до вызова метода doInBackground), STARTED (до вызова метода done), DONE (завершение задачи).

Текущее значение возвращается методом getState.

В этом примере мы создаем компонент JProgressBar, в конструкторе которого указываем минимальное и максимальное значения прогресс бара.

Метод setStringPainted (true) определяет, что в индикаторе отображается еще число – процент выполнения процесса.

В объекте SwingWorker мы используем его метод publish, который позволяет публиковать промежуточные результаты фонового вычисления в поток EDT.

Класс SwingWorker является типизированным.

Первый тип указывает тип значения, возвращаемый методом doInBackground, а второй тип указывает тип значения, публикуемый методом publish.

Публикуемое значение обрабатывается в методе process объекта SwingWorker.

Результаты множественных вызовов метода publish накапливаются для одного вызова метода process.

Поэтому его параметром служит список публикуемых значений.

Так как нас интересует последнее публикуемое значение, мы извлекаем его методом get из списка.

В методе doInBackground объекта SwingWorker с помощью метода setProgress мы изменяет значение связанного свойства progress.

Изменение этого свойства мы отслеживаем в слушателе объекта SwingWorker, который добавляем методом addPropertyChangeListener.

В обработчике этого слушателя мы извлекаем новое значение этого свойства и устанавливаем его как значение прогресс бара.

Метод setIndeterminate (true) устанавливает индикатор в неопределенный режим (indeterminate mode), в котором индикатор прокручивается в обе стороны.

Когда задача будет выполнена, нужно перевести индикатор в обычный режим методом setIndeterminate (false).

ProgressMonitor

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

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

Окно ProgressMonitor отображается самостоятельно.

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

Если это время больше, чем 2 секунды, появляется всплывающее окно индикатора.

В этом примере для изменения строки окна мы используем метод publish и метод process, в котором изменяем строку индикатора методом setNote.

В слушателе связанного свойства progress объекта SwingWorker мы изменяем значение индикатора методом setProgress.

Индикатор Progress Bar используется, если вы хотите контролировать конфигурацию.

Для Progress Bar вы можете установить его неопределенным, сделать его отображаемым по вертикали, отображать процент выполнения на нем.

Вместе с Progress Bar вы можете отображать другие компоненты.

Также вы можете отображать несколько индикаторов Progress Bar.

Вы можете повторно использовать индикатор Progress Bar.

Окно Progress Monitor нельзя использовать повторно.

После того, как монитор прогресса решил отобразить диалоговое окно, он не сможет сделать это снова.

Окно Progress Monitor используется, если вам нужен простой способ отображения прогресса в диалоговом окне.

Окно Progress Monitor предоставляет пользователю возможность отклонить диалог во время выполнения задачи.

Также задача может быть отменена с помощью кнопки Cancel окна.

Окно Progress Monitor предоставляет метод setNote, чтобы задача могла предоставить дополнительную информацию о том, что она делает.

Вы можете контролировать появление окна или его не появление в зависимости от времени выполнения задачи с помощью метода setMillisToPopup.