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

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

Самой первой графической библиотекой платформы Java была библиотека AWT набора JDK 1.0.

Далее библиотека AWT была дополнена библиотекой Java 2D двухмерной графики и изображений.

Библиотека AWT обеспечивает для разработчика приложений возможность использования таких основных компонентов GUI-интерфейса как кнопка, флажок, список выбора, прокручивающийся список, метка, диалоговое окно, окно выбора файла, меню, панель с прокруткой, текстовая область и текстовое поле, использования функции Drag-and-Drop, возможность обработки событий UI-компонентов, компоновки компонентов в рабочей области, работы с цветом, шрифтом, графикой, рисования и печати.

Библиотека AWT считается тяжеловесной, так как она содержит нативную библиотеку java.awt.peer, через которую взаимодействует с операционной системой компьютера таким образом, что AWT-компоненты имеют своих двойников, реализованных для конкретной операционной системы, с которыми они связаны интерфейсами пакета java.awt.peer.

Поэтому отображение AWT GUI-интерфейса зависит от операционной системы, в которой приложение развернуто.

Для расширения набора GUI-компонентов библиотеки AWT, устранения ее тяжеловесности и возможности выбора внешнего вида и поведения (Look and Feel) GUI-компонентов была создана графическая библиотека Swing.

Библиотека Swing основывается на библиотеке AWT и напрямую не связана, как библиотка AWT, с операционной системой, в которой она работает.

Поэтому библиотека Swing является уже легковесной.

Кроме того, библиотека Swing дополняет библиотеку AWT такими компонентами GUI-интерфейса как панель выбора цвета, индикатор состояния, переключатель radio button, слайдер и спиннер, панель с закладками, таблицы и деревья, расширенными возможностями компоновки GUI-компонентов, таймером, возможностью отображения HTML-контента.

С помощью библиотеки Swing стало возможным создать набор отображений Look and Feel, которые разработчик может выбирать, не оглядываясь на операционную систему, и изменять внешний вид GUI-интерфейса.

Также библиотека Swing реализует архитектуру MVC (Model-View-Controller) и потоковую модель Event Dispatch Thread (EDT).

Библиотека SWT (Standard Widget Toolkit) является альтернативой библиотекам AWT/Swing, однако она не включена в официальный релиз JRE/JDK.

Библиотека SWT была создана в процессе работы над проектом Eclipse и является попыткой взять лучшее из архитектур библиотек AWT и Swing и предоставить возможность создания быстрых GUI-интерфейсов с отображением Look and Feel, как можно более полно соответствующим операционной системе, в которой они работают.

Архитектура системы SWT построена таким образом, что SWT-компоненты представляют собой лишь Java-оболочки GUI-компонентов конкретной операционной системы.

Для операционной системы, в которой отсутствует реализация какого-либо компонента, система SWT обеспечивает Java-эмуляцию.

Так в системе SWT достигается скорость работы и полное соответствие внешнему виду и поведению операционной системе.

Для создания GUI-интерфейса система SWT предоставляет такие GUI-компоненты как кнопка, включая флажок и переключатель, список, метка, меню, текстовая область, диалоговое окно, индикатор прогресса, панель с прокруткой, слайдер и спиннер, таблица и дерево, панель с вкладками, панель выбора даты, панель инструментов, встроенный Web-браузер, гиперссылка, а также обеспечивает компоновку SWT-компонентов, встраивание AWT-компонентов, отображение OpenGL-контента, печать, поддержку операций Drag and Drop, 2D-графики, технологии Win32 OLE.

Библиотека JFace дополняет библиотеку SWT и создана на основе библиотеки SWT с реализацией архитектуры MVC (Model-View-Controller), предоставляя такие MVC GUI-компоненты как таблица, дерево, список, текстовая область и диалоговое окно, обеспечивая определение пользовательских команд независимо от их представления в GUI-интерфейсе, управление шрифтами и изображениями, помощь пользователю в выборе соответствующего содержания для полей в GUI-компонентах, выполнение длительных задач.

Библиотека Java 3D была создана как высокоуровневая библиотека для создания 3D графики, включая анимацию 3D-объектов.

Библиотека Java 3D не включена в официальный релиз JRE/JDK и требует отдельной установки.

Библиотека Java 3D оперирует объектами, размещаемыми в графе сцены, который представляет собой дерево 3D-объектов и предназначен для визуализации.

Java3D-приложение может работать как настольное приложение, как апплет или как настольное приложение и апплет.

По сути, библиотека Java 3D является оберткой графических библиотек OpenGL и DirectX.

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

Кроме того, данные библиотеки не обеспечивают возможность декларативного создания GUI-интерфейса на основе языка XML.

Библиотека JavaFX была создана как универсальная платформа, предоставляющая современные GUI-компоненты с возможностью их декларативного описания, богатый набор библиотек для работы с медиаконтентом и 2D/3D графикой, а также высокопроизводительную среду выполнения приложений.

Первоначально, с 2007 по 2010 год, версии 1.1, 1.2 и 1.3 платформы JavaFX содержали:

– Декларативный язык программирования JavaFX Script создания UI-интерфейса.

– Набор JavaFX SDK, обеспечивающий компилятор и среду выполнения.

– Плагины для сред выполнения NetBeans IDE и Eclipse.

– Плагины для Adobe Photoshop и Adobe Illustrator, позволяющие экспортировать графику в код JavaFX Script, инструменты конвертации графического формата SVG в код JavaFX Script.

Платформа JavaFX версии 2.0 выпуска 2011 года кардинально отличалась от платформы JavaFX версии 1.х.

Платформа JavaFX 2.х больше не поддерживала язык JavaFX Script, а вместо этого предлагала новый программный интерфейс JavaFX API для создания JavaFX-приложений полностью на языке Java.

Для альтернативного декларативного описания графического интерфейса пользователя платформа JavaFX 2.х предлагала новый язык FXML.

Кроме того, платформа JavaFX 2.х обеспечивала новые графический и медиа движки, улучшающие воспроизведение графического и мультимедийного контента, обеспечивала встраивание HTML-контента в приложения, новый плагин для Web-браузеров, широкий выбор GUI-компонентов с поддержкой CSS3, 2D графику, создание отчетов с диаграммами, интеграцию с библиотекой Swing.

При этом платформа JavaFX версии 2.х содержала:

– Набор JavaFX SDK, предоставляющий инструмент JavaFX Packager tool компиляции, упаковки и развертывания JavaFX-приложений, Ant-библиотеку для сборки JavaFX-приложений, библиотеки JavaFX API и документацию.

– Среду выполнения JavaFX Runtime для работы настольных JavaFX-приложений и JavaFX-апплетов.

– Поддержку платформы JavaFX 2.х для среды выполнения NetBeans IDE 7.

– Примеры JavaFX-приложений.

– Приложение JavaFX Scene Builder 1.х для визуальной компоновки GUI-компонентов в GUI-интерфейс с использованием языка FXML.

В дальнейшем платформа JavaFX была полностью интегрирована в платформу Java 8, и перестала требовать отдельной инсталляции.

Кроме того, платформа JavaFX 8 была дополнена программным интерфейсом CSS API создание стилей, интеграцией с библиотекой SWT, программным интерфейсом Printing API, 3D графикой, программным интерфейсом SubScene API.

Также платформа JavaFX 8 предлагает улучшенный инструмент JavaFX Scene Builder 2.х для визуальной компоновки GUI-компонентов в GUI-интерфейс на основе языка FXML, дополненный поддержкой новых возможностей платформы JavaFX 8, программным интерфейсом JavaFX Scene Builder Kit для встраивания инструмента в Java приложения, возможностью добавлять пользовательские GUI-компоненты и др.

В настоящее время технология JavaFX обеспечивает создание мощного графического интерфейса пользователя (Graphical User Interface (GUI)), 2D и 3D графику для крупномасштабных приложений, ориентированных на обработку данных, насыщенных медиа-приложений, поставляющих разнообразный медиа-контент пользователю, Mashup-приложений, объединяющих различные Web-ресурсы для пользователя, обеспечивает создание компонентов высококачественной графики и анимации для Web-сайтов, различного рода пользовательских программ, насыщенных графикой, анимацией и интерактивными элементами.

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

С помощью Java Web Start пользователи запускают приложения, перейдя по ссылке на веб-странице.

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

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

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

Технология, лежащая в основе Java Web Start, – это протокол Java Network Launching Protocol & API (JNLP).

Java Web Start – это эталонная реализация для спецификации JNLP.

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

С технологической точки зрения Java Web Start имеет ряд преимуществ.

Технология Java Web Start построена исключительно для запуска приложений, написанных на платформе Java, Standard Edition.

Таким образом, одно приложение может быть доступно на веб-сервере, а затем развернуто на самых разных платформах, включая Windows, Linux и macOS.

Java Web Start поддерживает несколько версий платформы Java Standard Edition.

Таким образом, приложение может запрашивать определенную версию требуемой платформы, например, Java SE 9.

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

Java Web Start позволяет запускать приложения независимо от веб-браузера.

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

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

Java Web Start использует функции безопасности платформы Java.

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

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

Приложения, запущенные с помощью Java Web Start, локально кэшируются.

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

Java Web Start входит в состав платформы Java Platform, Standard Edition (JDK) и Java Runtime Environment (JRE) и поддерживает функции безопасности платформы Java.

Это означает, что приложение, запускаемое с помощью Java Web Start, должно быть подписано доверенным сертификатом.

Что значительно сужает применение Java Web Start, так как получение доверенного сертификата является платным.

Таким образом, с помощью Java Web Start приложение можно запустить тремя способами:

Из веб-браузера, нажав ссылку.

Из значка на рабочем столе или в меню «Пуск».

Из Java Cache Viewer.

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

При запуске из веб-браузера используется HTML-ссылка, которая вместо того, чтобы указывать на другую веб-страницу, ссылается на специальный файл конфигурации, называемый JNLP-файлом.

Веб-браузер проверяет расширение файла или тип MIME файла и видит, что он принадлежит Java Web Start.

Поэтому браузер запускает Java Web Start с загруженным файлом JNLP в качестве аргумента.

Далее уже Java Web Start работает с загрузкой, кэшированием и запуском приложения, как это описано в файле JNLP.

Также технология Java Web Start может автоматически создавать ярлыки для вашего приложения на рабочем столе и в меню «Пуск».

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

Ярлыки также можно добавить с помощью Java Web Start Cache Viewer.

При первой загрузке приложения c помощью технологии JWS все необходимые файлы сохраняются в компьютере пользователя в специальной папке cache, поэтому повторно запустить приложение можно без использования браузера и соединения с интернетом, с помощью Java Cache Viewer.

Интерфейс Java Cache Viewer позволяет запустить приложение, просмотреть JNLP-файл приложения, инсталлировать ярлык приложения на рабочем столе компьютера, удалить приложение с компьютера и перейти на домашнюю страничку приложения.

Интерфейс Java Cache Viewer отражает в качестве названия приложения заголовок главного окна приложения, а не имя JAR-файла.

Открыть интерфейс Java Cache Viewer можно с помощью контрольной панели Java, которая находиться в панели управления компьютером.

JNLP-файл представляет собой XML-файл, содержащий инструкции для JWS-инструмента javaws как загружать и запускать приложение.

Именно расширение файла. jnlp, при инсталляции JRE, связывается с Java-инструментом javaws, поэтому при открытии JNLP-файла автоматически запускается загрузчик javaws.

В среде разработки NetBeans включить использование технологии Java Web Start можно в свойствах проекта, при этом в процессе сборки проекта будут созданы все необходимые артефакты.

Зачем же Java уничтожила апплеты?

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

Они должны рассмотреть возможность перехода с Java-апплетов на технологию Java Web Start без плагинов или просто настольные приложения.

Поддержка Java в браузерах возможна только до тех пор, пока поставщики браузеров будут поддерживать плагин.

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

Поэтому, Oracle решила отказаться от Java плагина браузера в JDK 9.

Однако приложения Java Web Start не полагаются на плагин браузера и не будут затронуты этими изменениями.

Пакет java.awt.color используется для создания цвета.

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

Пакет java.awt. dnd реализует технологию Drag-and-Drop.

Пакет java.awt.font обеспечивает поддержку шрифтов.

Пакет java.awt.geom реализует двухмерную геометрию.

Пакет java.awt.im обеспечивает поддержку нестандартных методов ввода текста.

Пакет java.awt.image используется для создания и редактирования графических изображений.

Пакет java.awt.print обеспечивает поддержку печати.

Так как AWT-компоненты основываются на peer-объектах, то использование библиотеки AWT является потоково-безопасным (thread safe), поэтому не нужно беспокоиться о том, в каком потоке обновляется состояние графического интерфейса.

Однако беспорядочное использование потоков может замедлять работу AWT-интерфейса.

Суммируя сказанное, можно сказать, что графическая библиотека AWT представляет собой промежуточный уровень между операционной системой и Java-кодом приложения, скрывая все низкоуровневые операции, связанные с построением графического интерфейса пользователя.

Такое прямое взаимодействие с конкретной операционной системой является и основным недостатком AWT, так как графический интерфейс, созданный на основе AWT, в операционной системе Windows выглядит как Windows-подобный, а в операционной системе Macintosh выглядит как Mac-подобный.

Казалось бы, при наличии таких графических Java-библиотек, как Swing, SWT, Java3D, JavaFX, библиотека AWT должна потерять свою актуальность.

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

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

Вернемся к иерархии классов AWT.

Класс Component находится наверху иерархии AWT.

Component – это абстрактный класс, который инкапсулирует все атрибуты визуального компонента.

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

Container – это компонент AWT, который содержит другие компоненты, такие как кнопка, текстовое поле, таблицы и т. д.

Контейнер является подклассом класса компонентов.

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

Класс Panel – это конкретный подкласс класса Container.

Панель не содержит строку заголовка, строку меню или границу.

Это контейнер, который используется для содержания компонентов.

Класс Window создает окно верхнего уровня. Окно не имеет границ и меню.

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

Таким образом, для создания AWT приложения, в первую очередь, нужно создать объект Frame как окно верхнего уровня.

Здесь мы создаем объект Frame, устанавливаем его размеры и делаем его видимым.

В результате получаем окно с заголовком и кнопками минимизации и закрытия окна.

Однако закрыть такое окно мы не сможем.

Для этого мы должны добавить слушателя событий окна.

Абстрактный класс WindowAdapter реализует интерфейсы слушателя событий окна и предназначен для получения событий окна.

Метод windowClosing вызывается при нажатии кнопки закрытия окна.

И мы определяем этот метод, вызывая в нем метод exit системы.

Таким образом, теперь мы можем закрыть это окно.

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

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

Каждый регион называется панелью.

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

Панели не имеют видимых ограничивающих линий.

Вы можете разграничить их разными цветами фона.

Метод setLayout класса Container устанавливает компоновку LayoutManager, которая отвечает за расположение элементов контейнера.

Существует пять стандартных AWT компоновок – классов, реализующих интерфейс LayoutManager, это FlowLayout, BorderLayout, CardLayout, GridLayout, и GridBagLayout.

Компоновка FlowLayout является компоновкой по умолчанию для панели, поэтому мы могли бы ее не устанавливать для панели методом setLayout.

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

Метод setSize работать не будет.

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

Компоненты в строках по умолчанию находятся в центре.

Выравнивание компонента в строке можно изменить с помощью константы FlowLayout. LEFT или FlowLayout. RIGHT в конструкторе класса FlowLayout.

Компоновка BorderLayout является компоновкой по умолчанию для окон Frame и Dialog, поэтому мы можем ее не устанавливать для окна методом setLayout.

Эта компоновка разделяет контейнер на пять регионов.

Каждый регион идентифицируется соответствующей константой BorderLayout – NORTH, SOUTH, EAST, WEST, и CENTER

NORTH и SOUTH изменяют размер компонента до его предпочтительной высоты.

EAST и WEST изменяют размер компонента до его предпочтительной ширины.

Центру предоставляется оставшееся пространство.

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

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

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

Элементы размещаются в ячейки слева направо, сверху вниз.

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

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

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

По умолчанию создается одна строка с одним столбцом.

Компоновка устанавливается для контейнера методом setLayout и затем компоненты добавляются в контейнер методом add.

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

Эта компоновка хорошо подходит для размещения единственного компонента в окне.

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

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

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

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

Затем создается экземпляр GridBagConstraints, параметры которого изменяются для каждого компонента.

gridx и gridy указывают номер ячейки для компонента.

gridwidth и gridheight указывают количество столбцов и строк, которые компонент занимает.

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

ipady и ipadx указывают отступ.

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

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

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

До сих пор мы рассматривали окно Frame.

Однако помимо окна Frame, библиотека AWT позволяет создавать диалоговые окна с помощью класса Dialog.

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

Также можно указать заголовок окна и будет ли окно модальным, то есть будет ли оно блокировать все входные данные для окон верхнего уровня.

Далее можно наполнить диалоговое окно содержимым, напомним, что по умолчанию компоновка диалогового окна – это BorderLayout.

Для закрытия окна, к его компоненту нужно присоединить слушателя, в обработчике которого нужно вызвать метод setVisible (false) окна, сделав его невидимым.

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

И наконец, методом add нужно добавить диалоговое окно в основное окно, как обычный компонент.

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

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

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

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

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

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

В AWT существуют две разные модели событий или способы обработки событий.

В Java 1.0 и ранее события отправлялись непосредственно соответствующим компонентам.

Сами события были инкапсулированы в один класс Event.

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

Таким образом, в этой ранней модели обработчики событий, такие как action и handleEvent, были реализованы классом Component.

И версии этих методов по умолчанию ничего не делали и возвращали false.

Эта модель событий была заменена моделью Java 1.1.

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

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

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

В модели событий Java 1.1 вся функциональность обработки событий содержится в пакете java.awt. event.

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

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

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

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

Пакет также содержит ряд классов адаптеров.

Они реализуют интерфейсы EventListener и являются абстрактными классами, которые предоставляют нулевые реализации методов соответствующего прослушивателя.

Эти классы удобны для создания объектов-слушателей.

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

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

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

Эта модель называется «делегирование».

Она реализует шаблон проектирования Observer.

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

Важно, чтобы любой объект, а не только компонент, мог получать события.

Таким образом, вы можете отделить свой код обработки событий от вашего графического интерфейса.

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

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

Модель делегирования важна для JavaBeans, которые позволяют взаимодействовать между Java и другими платформами.

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

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

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

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

В Java 1.1 это не требуется.

Событие будет передано каждому объекту, зарегистрированному в качестве слушателя для этого события, независимо от того, что другие объекты делают с событием.

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

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

В Java 1.1 каждый компонент является источником события, который может генерировать определенные типы событий, которые являются подклассами класса AWTEvent.

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

Каждый тип события соответствует интерфейсу прослушивателя, который определяет методы, вызываемые при возникновении события.

Чтобы получить событие, объект должен реализовать соответствующий интерфейс слушателя и должен быть зарегистрирован в источнике события, путем вызова метода «add listener» компонента, который генерирует событие.

И мы это уже видели.

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

В этом классе мы переопределяем обработчик событий, метод интерфейса слушателя.

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

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

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

Некоторые интерфейсы слушателей предназначены для работы с несколькими типами событий.

Например, интерфейс MouseListener объявляет пять методов обработки различных типов событий мыши: мышь вниз, мышь вверх, щелчок, вход мыши в компонент и выход мыши.

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

Это звучит как создание излишнего кода; большую часть времени вас интересует только одно или два из этих событий.

К счастью, вам этого делать не нужно.

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

И если вы хотите написать класс обработки событий, который имеет дело только с щелчками мыши, вы можете объявить, что ваш класс расширяет MouseAdapter.

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

Таким образом, резюмируя.

Компоненты генерируют AWTEvents, когда что-то происходит.

Различные подклассы AWTEvent представляют различные типы событий.

Например, события мыши представлены классом MouseEvent.

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

Обработчики событий регистрируются для приема событий с помощью метода «add listener» в компоненте, который генерирует событие.

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

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

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

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

Например, MouseListener определяет методы, вызываемые при возникновении событий мыши.

Большинство типов событий также имеют класс адаптера.

Например, события MouseEvent имеют класс MouseAdapter.

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

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

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

Класс EventQueue позволяет напрямую управлять событиями Java 1.1.

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

Однако, если вам нужно, вы можете получить очередь событий системы, вызвав Toolkit.getSystemEventQueue, затем вы можете заглянуть в очередь событий, вызвав peekEvent или опубликовать новые события, вызвав postEvent.

EventQueue – платформо-независимый класс, представляющий собой очередь событий, получаемых как из классов-помощников peer, которые организуют взаимодействие классов AWT с операционной системой, так и из классов приложения.

Данный класс обеспечивает диспетчеризацию событий, т.е. извлечение событий из очереди и отправки их вызовом внутреннего метода dispatchEvent (AWTEvent event), который в качестве параметра принимает объект класса AWTEvent, представляющий собой AWT события.

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

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

Метод dispatchEvent наследуется каждым компонентом от базового класса java.awt.Component.

Далее событие передается из метода dispatchEvent методу processEvent (AWTEvent e), который в свою очередь передает событие методу process <event type> Event, определенному для каждого класса событий.

После этого метод process <event type> Event передает событие объекту интерфейса <event type> Listener, зарегистрированному соответствующим слушателем add <event type> Listener, где событие и обрабатывается методом, определенном в интерфейсе.

Объект класса EventQueue автоматически создается виртуальной машиной Java, когда приложением создается объект – наследник класса java.awt.Component.

При этом автоматически создается также объект класса java.awt. EventDispatchThread, который представляет собой поток, работающий параллельно основному потоку программы.

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

Методом pumpEvents класса EventDispatchThread события извлекаются из очереди и передаются методу dispatchEvent класса EventQueue.

Таким вот образом события передаются от источника слушателю.

Это элементы пользовательского интерфейса.

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

Макеты или компоновки.

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

И поведение.

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

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

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

Когда кнопка нажата и отпущена, AWT отправляет экземпляр ActionEvent события к кнопке, вызывая метод processEvent кнопки.

Метод processEvent кнопки получает все события для кнопки, и он передает событие, вызывая собственный метод processActionEvent.

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

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

Элемент Сheckbox используется для включения опции (true) или ее выключения (false).

Для каждого флажка есть метка, обозначающая, что делает флажок.

И состояние флажка можно изменить, щелкнув по нему.

Объект флажка создается с помощью конструктора, которому передается метка флажка.

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

Здесь используется слушатель ItemListener, а не ActionListener.

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

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

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

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

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

Компонент выбора Choice используется для отображения всплывающего меню выбора.

Выбранный элемент отображается в верхней части меню.

Класс Choice имеет метод getSelectedItem, который возвращает выбранный элемент в виде строки.

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

Метка просто отображает одну строку текста, доступную только для чтения.

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

Список List представляет собой список текстовых элементов.

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

В этом отличие списка от выбора Choice.

Также List – это статический список, а не выпадающий список выбора, как Choice.

Компоненты List, TextArea и ScrollPane поставляются с готовыми полосами прокрутки.

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

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

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

Или они могут использоваться для пролистывания нескольких экранов.

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

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

Также мы должны определить методы расчета размеров компонента и метод paint отрисовки компонента.

В конструкторе этого класса мы создаем горизонтальную и вертикальную полосы прокрутки.

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

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

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

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

Для обработки этого события определяется метод adjustValueChanged интерфейса AdjustmentListener.

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

В методе paint мы рисуем круг с диаметром, на основе значений полос прокрутки.

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

Элемент управления TextArea в AWT предоставляет многострочную область редактора.

Пользователь может вводить здесь столько, сколько он хочет.

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

При создании компонента TextArea указывается количество строк и столбцов видимой области текста.

Компонент TextField позволяет пользователю редактировать одну строку текста.

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

Событие нажатия клавиши передается зарегистрированному слушателю KeyListener.

Также можно обрабатывать событие ActionEvent, которое запускается нажатием клавиши enter.

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

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

Метод setEchoCharacter указывает символ, который будет отображаться вместо символов, вводимых пользователем.

Этот метод используется для ввода паролей.

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

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

Для создания меню, пакет java.awt предоставляет четыре основных класса – MenuBar, Menu, MenuItem и CheckboxMenuItem.

Все эти четыре класса не являются компонентами AWT, поскольку они не являются подклассами класса Component.

На самом деле, они являются подклассами класса MenuComponent, который никак не связан в иерархии с классом Component.

Панель меню MenuBar содержит само меню.

MenuBar добавляется к Frame с помощью метода setMenuBar.

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

MenuBar не может быть добавлена к другим сторонам окна.

Меню Menu содержит пункты меню.

Меню добавляется в панель меню с помощью метода add.

В меню можно добавить подменю.

Элемент MenuItem отображает опцию, которую может выбрать пользователь.

Элементы меню добавляются в меню с помощью метода addMenuItem.

Между пунктами меню может быть добавлен разделитель с помощью метода addSeparator.

Элемент CheckboxMenuItem отличается от элемента MenuItem тем, что он отображается вместе с флажком.

В этом примере сначала мы создаем панель меню.

Затем создаем меню.

Далее создаем элементы меню и присоединяем к ним слушателей событий.

Метод setActionCommand устанавливает имя команды для события действия, которое генерируется этим пунктом меню.

По умолчанию для команды действия, имя устанавливается как метка элемента меню.

Затем элемент меню добавляется в меню.

Меню добавляется в панель меню.

А панель меню устанавливается для окна верхнего уровня.

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

Для этого класс PopupMenu предоставляет метод show, который в качестве аргумента получает компонент, в котором отображается всплывающее меню, и координаты позиции для отображения меню.

В этом примере мы создаем всплывающее меню.

И в слушателе клика мыши панели, показываем всплывающее меню.

Для использования Canvas создается класс, расширяющий Canvas, и переопределяется метод paint, отвечающий за отрисовку холста.

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

Класс Graphics обеспечивает основу для всех графических операций в AWT.

Он играет две разные, но связанные роли.

Во-первых, это графический контекст.

Графический контекст – это информация, которая влияет на операции рисования.

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

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

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

Экземпляр Graphics создается при создании компонента и передается в качестве аргумента методам update и paint компонента.

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

Виртуальная машина Java предоставляет необходимые конкретные классы для вашей среды.

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

Класс Graphics позволяет нарисовать линию.

Закрасить цветом овал и прямоугольник.

Нарисовать строку текста и другое.

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

Здесь вызов метода drawImage запускает новый поток, который загружает запрошенное изображение.

Последний аргумент метода this – это наблюдатель изображения, который отслеживает процесс загрузки изображения.

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

Класс Component реализует интерфейс ImageObserver, поэтому можно использовать this в качестве наблюдателя изображения при вызове метода drawImage.

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

Каждая платформа, поддерживающая Java, должна предоставить конкретный класс, который расширяет класс Toolkit.

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

Чтобы использовать функции Java 2D API в приложении, нужно привести объект Graphics, переданный в метод рендеринга компонента, к объекту Graphics2D.

И объект Graphics2D предоставит следующие функции:

Это отображение набора примитивов, реализующих интерфейс Shape.

При этом примитив может быть заполнен цветом и его контуры могут быть нарисованы с указанием определенной толщины и шаблоном штрихов.

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

Также Graphics2D позволяет конвертировать текстовую строку в глифы, которые затем могут быть заполнены цветом.

Примитивы – это точки, линии, прямоугольники, эллипсы, дуги, кривые.

Также можно нарисовать произвольную форму с помощью пути рисования GeneralPath.

Контур примитива можно определить с помощью объекта Stroke.

А заполнить примитив цветом можно с помощью объекта Paint.

Java 2D API предоставляет различные возможности для отображения текста, включая установку атрибутов шрифта и выполнения компоновки текста.

Если вы просто хотите нарисовать статическую текстовую строку, проще всего это сделать с помощью метода drawString класса Graphics, указав шрифт методом setFont класса Graphics.

Если вы хотите контролировать качество отображения текста и его компоновку, вы можете использовать Java 2D API.

Java 2D API позволяет контролировать качество отображения с помощью подсказок класса RenderingHints, например, указав сглаживание текста.

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

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

Этот процесс называется компоновкой текста.

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

Что касается изображений, Java 2D API позволяет загрузить внешний файл изображения формата GIF, PNG, JPEG во внутреннее представление изображения, используемое Java 2D.

Непосредственно создать 2D Java изображение и отобразить его.

Отрисовать содержимого 2D-изображения Java на поверхности.

Сохранить содержимое 2D Java изображения во внешний файл изображения GIF, PNG или JPEG.

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

И класс BufferedImage, который расширяет класс Image, чтобы приложение могло работать непосредственно с данными изображения, например, извлечение или настройка цвета пикселя.

И приложения могут напрямую создавать экземпляры этого класса.

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

Так как BufferedImage является подклассом Image, его контент может быть визуализирован с помощью методов Graphics и Graphics2D, которые принимают параметр Image.

Для загрузки изображения из внешнего источника используется Image I/O API, которое поддерживает форматы изображения GIF, PNG, JPEG, BMP.

Соответственно Image I/O API используется и для сохранения объекта BufferedImage во внешний формат изображения.

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

Для отрисовки полученного изображения нужен объект Graphics или Graphics2D.

Если мы не используем метод paint или update компонента, получить объект Graphics2D можно вызвав метод createGraphics, но только изображения, которое вы создали сами.

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

Используя возможность получения графического контекста из изображения, можно, например, создать свое изображение, рисуя в нем с помощью объекта Graphics или Graphics2D.

Работа с изображениями

AWT предоставляет некоторые возможности для управления изображениями с помощью пакета java.awt.image.

Как мы уже говорили, получить изображение из внешнего источника можно с помощью объекта Toolkit.

Затем с помощью BufferedImage мы можем получить объект графического контекста и нарисовать изображение.

Далее вы можете масштабировать это изображение.

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

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

Таким образом, вы можете вызвать методы getWidth и getHeight до того, как Java узнает размер изображения.

В этом случае размер изображения будет установлен в -1.

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

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

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

Мы добавляем изображение для отслеживания и вызываем метод waitForID, который начинает загрузку изображения, отслеживаемого этим медиа-трекером, с указанным идентификатором.

Этот метод ожидает завершения загрузки изображения с указанным идентификатором.

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

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

ImageObserver определяет только один метод: ImageUpdate ().

Использование наблюдателя изображения позволяет выполнять (параллельно с загрузкой изображения) другие действия, такие как показ индикатора хода работы или дополнительного экрана, который информирует о ходе загрузки изображения.

Многие из разработчиков Java находили интерфейс ImageObserver слишком сложным для понимания и управления загрузкой множественных изображений.

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

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

Здесь показан код, который позволяет сделать это.

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

Сначала мы получаем размер изображения.

Затем создаем массив для пикселей изображения.

Далее создаем объект PixelGrabber, который с помощью метода grabPixels позволяет извлечь пиксели в массив, указанный при создании объекта PixelGrabber.

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

Для создания изображения из массива пикселей используется вспомогательный класс MemoryImageSource и объект Toolkit.

И наконец полученное изображение можно нарисовать.

На слайде показано, как создаются данные изображения за сценой.

Производитель изображения – это объект, который реализует интерфейс ImageProducer, и создает необработанные данные для объекта изображения Image.

Производитель изображения предоставляет эти данные потребителю изображения – объекту, который реализует интерфейс ImageConsumer.

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

AWT автоматически использует производителя и потребителя изображения за сценой.

При создании экземпляра класса Image требуется наличие производителя изображений.

Код глубоко внутри AWT создает производителя изображений.

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

При рисовании экземпляра класса Image методом draw, глубоко внутри AWT создается потребитель изображения.

Здесь показано, как при создании пользовательского компонента, можно с помощью метода createImage класса Component создать пользовательское изображение, реализуя собственные ImageProducer и ImageConsumer, и нарисовать это изображение в методе paint компонента.

Java позволяет «фильтровать» изображения с помощью класса ImageFilter или его подклассов.

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

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

ImageFilter реализует интерфейс ImageConsumer, поскольку фильтр изображения перехватывает сообщения, которые производитель отправляет потребителю.

Для использования фильтра, создается объект фильтра.

Далее нужно создать объект класса ImageProducer.

Этот объект создается при помощи конструктора класса FilteredImageSource.

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

Затем мы можем создать новое изображение методом createImage.

Чтобы дождаться процесса завершения формирования изображения, используйте класс MediaTracker.

После этого изображение готово и доступно для рисования методом drawImage.

Все фильтры изображений должны быть подклассами класса ImageFilter.

Если ваш фильтр изображения изменяет цвета или прозрачность изображения, вы можете создать подкласс класса RGBImageFilter, который расширяет класс ImageFilter.

Здесь показан простой фильтр изображения, который отфильтровывает отдельные цветовые компоненты (красный, зеленый и синий) изображения.

Класс ColorFilter расширяет класс RGBImageFilter и содержит три логические переменные, которые определяют, какие цвета должны быть отфильтрованы из изображения.

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

Переменная canFilterIndexColorModel, унаследованная от RGBImageFilter, установлена в значение true, чтобы указать, что записи цветовой карты могут быть отфильтрованы, если входящее изображение использует модель индексированного цвета.

В Java цвета пикселей управляются через цветовые модели.

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

Цветовая модель представляет собой объект Java, который предоставляет методы для перевода значений пикселей в соответствующие красные, зеленые и синие цветовые компоненты изображения.

Это может показаться тривиальной задачей, зная, что компоненты цвета пикселей аккуратно упакованы в 32-битное значение.

Тем не менее, существуют различные типы цветовых моделей, отражающие различные методы определения цветов пикселей.

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

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

Модель индексированных цветов поддерживается 8-битными изображениями, содержащими не более 256 цветов.

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

Эта позволяет уменьшить размер файла изображения, при этом сохраняя качество изображения.

Вернемся к нашему примеру.

Помимо конструктора, класс ColorFilter реализует только один метод filterRGB, который является абстрактным методом, определенным в классе RGBImageFilter.

Метод filterRGB принимает три параметра: положение x и y пикселя внутри изображения и 32-битное (целочисленное) значение цвета.

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

Стандартная цветовая модель RGB помещает красные, зеленые и синие компоненты в нижние 24 бита 32-битного значения цвета.

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

Эти отдельные компоненты хранятся в локальных переменных r, g и b.

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

Для фильтрованных цветов, компонент цвета установлен в 0.

Новые цветовые компоненты затем переносятся обратно в 32-битное значение цвета и возвращаются из метода filterRGB.

Обратите внимание, что альфа-компонент значения цвета не изменяется.

Для этого используется маска 0xff000000, потому что альфа-компонент находится в верхнем байте значения цвета.

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

Java поддерживает фильтрацию изображений с помощью интерфейса BufferedImageOp.

Метод filter интерфейса BufferedImageOp принимает объект BufferedImage как вход (исходное изображение) и выполняет обработку данных изображения, создавая другой объект BufferedImage (конечное изображение).

Напомним, что класс BufferedImage расширяет класс Image, обеспечивая доступ к буферу данных изображения.

Java 2D API предоставляет набор реализаций интерфейса BufferedImageOp.

AffineTransformOp – преобразует изображение геометрически.

ColorConvertOp – выполняет по-пиксельное преобразование цвета в исходном изображении.

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

LookupOp – изменяет отдельные составляющие цвета.

RescaleOp – изменяет интенсивность изображения.

Здесь показан пример применения фильтра RescaleOp, изменяющего интенсивность цвета.

В этом примере сначала создается исходный объект BufferedImage на основе изображения, затем создается пустой объект BufferedImage.

Который заполняется отфильтрованными данными исходного изображения, с помощью метода filter созданного объекта RescaleOp.

Нажмем правой кнопкой мыши на пакете приложения, и в меню выберем New – GUI Form.

Введем имя формы.

В результате будет создан Java класс и связанное с ним XML описание, которое открывается в редакторе IntelliJ IDEA GUI Designer.

Редактор IntelliJ IDEA GUI Designer позволяет создавать графические пользовательские интерфейсы (GUI) приложения, используя компоненты библиотеки Swing.

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

Когда вы создаете форму с помощью GUI Designer, вы создаете панель, а не фрейм.

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

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

У него должен быть ярлык, помещаемый в палитру компонентов.

Среди полей компонента должны быть выделены свойства (properties), которые будут показаны в окне свойств.

У него должны быть определены методы доступа getXxx () /setXxx () /isXxx () к каждому свойству.

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

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

В него может входить один или несколько классов.

Как правило, файлы этих классов упаковываются в один jar-файл и отмечаются в его файле MANIFEST. MF как Java-Bean: True.

Все компоненты AWT и Swing являются компонентами JavaBeans.

Спецификация Sun Microsystems определяет JavaBeans как повторно используемые программные компоненты, которыми можно управлять, используя графические конструкторы и средства IDE.

Визуальные средства разработки – это не основное применение JavaBeans.

Главное достоинство компонентов, оформленных как JavaBeans, в том, что они без труда встраиваются в любое приложение.

И приложение можно собрать из готовых JavaBeans как из строительных блоков, остается только настроить их свойства.

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

Чтобы класс мог работать как bean, он должен соответствовать определённым соглашениям об именах методов, конструкторе и поведении.

Эти соглашения дают возможность создания инструментов, которые могут использовать, замещать и соединять JavaBeans.

Эти соглашения следующие:

Класс должен иметь конструктор без параметров, с модификатором доступа public.

Такой конструктор позволяет инструментам создать объект без дополнительных сложностей с параметрами.

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

Это легко позволяет инструментам автоматически определять и обновлять содержание bean’ов.

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

Класс должен быть сериализуем.

Это даёт возможность надёжно сохранять, хранить и восстанавливать состояние bean независимым от платформы и виртуальной машины способом.

Класс должен иметь переопределенные методы equals, hashCode и toString.

В среде разработки NetBeans можно легко создать компонент JavaBeans с помощью меню New проекта приложения.

Для создания компонентов JavaBeans Java SE API включает в себя пакет java.beans.

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

Класс компонента JavaBeans содержит методы addPropertyChangeListener и removePropertyChangeListener для управления слушателями, и когда связанное свойство изменяется, компонент отправляет событие PropertyChangeEvent своим зарегистрированным слушателям.

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

Как и в случае со свойствами, события идентифицируются по определенной схеме имен методов, add <Event> Listener и remove <Event> Listener.

Другое понятие, с которым вы можете столкнуться – это Plain Old Java Object.

Plain Old Java Object – это объект Java, который не расширяет или не реализует специализированные классы и интерфейсы каких-либо фреймворков.

POJO это просто класс Java, который содержит только поля, без логики их обработки и обеспечивает доступ ко все полям только через методы get/set.

Компоненты JavaBeans дополняют Plain Old Java Object наличием конструктора по умолчанию и наличием слушателей listener изменения свойств.

То есть Plain Old Java Object описывает структуру данных для дальнейшего использования в приложении.

Механизм, который делает возможным такое сохранение, называется сериализацией.

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

Любое приложение, которое использует такой компонент, может затем «восстановить» его путем десериализации.

Затем объект возвращается в исходное состояние.

Например, приложение Java может сериализовать окно Frame на машине Windows, сериализованный файл можно отправить с помощью электронной почты на машину Solaris, а затем приложение Java сможет восстановить окно Frame в точное состояние, существующее на машине Windows.

Чтобы так сохраняться, компоненты должны поддерживать сериализацию, реализуя либо интерфейс java.io.Serializable, либо интерфейс java.io.Externalizable.

При сериализации объекта в файл, по соглашению создается файл с расширением. ser.

Классы ObjectInputStream и ObjectOutputStream представляют собой потоки, которые содержат методы сериализации и десериализации объекта.

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

Если какой-либо класс в иерархии наследования класса реализует интерфейс Serializable или Externalizable, тогда этот класс и его подклассы сериализуются.

Примеры сериализуемых классов включают в себя классы Component, String, Date, Vector и Hashtable.

Известные классы, которые не поддерживающие сериализацию, включают в себя классы Image, Thread, Socket и InputStream.

Попытка сериализации объектов этих типов приведет к исключению NotSerializableException.

Java Object Serialization API автоматически сериализует большинство полей объекта Serializable в поток байтов.

Сюда входят примитивные типы, массивы и строки.

API не сериализует или десериализует поля, отмеченные как transient или static.

Transient (нерезидент) – модификатор полей класса.

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

При десериализации объекта такие поля инициализируются значением по умолчанию.

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

Вы можете контролировать уровень сериализации объекта.

Есть несколько способов управления серилизацией:

Это автоматическая сериализация, реализуемая интерфейсом Serializable.

Программное обеспечение сериализации Java сериализует весь объект, за исключением полей transient или static.

Интерфейс Serializable не объявляет никаких методов; он действует как маркер, сообщая инструментам сериализации объектов, что ваш класс сериализуется.

Маркировка класса интерфейсом Serializable означает, что вы сообщаете виртуальной машине Java (JVM), что ваш класс будет работать с сериализацией по умолчанию.

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

Этот конструктор будет вызываться, когда объект будет «восстанавливаться» из файла. ser, в котором хранится сериализованный объект.

Вам не нужно реализовывать Serializable в вашем классе, если он уже реализован в суперклассе.

Все поля, кроме полей transient или static, сериализуются.

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

Если объект однажды уже записанный в поток, спустя какое-то время записывается в него снова, то по умолчанию, ObjectOutputStream сохраняет ссылки на объекты, которые в него записываются.

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

Существует два способа это исправить.

Во-первых, вы можете каждый раз после вызова метода записи закрывать поток, а затем открывать его снова.

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

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

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

Метод writeObject класса определяет сериализацию объекта.

А метод readObject восстанавливает поток данных, который вы определили с помощью writeObject.

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

Для использования интерфейса Externalizable вам необходимо реализовать два метода: readExternal и writeExternal.

Классы, которые реализуют Externalizable, должны иметь конструктор без аргументов.

Класс XMLEncoder позволяет сериализовать объект в XML-файл.

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

Вы также можете изменить данные в файле в текстовом редакторе.

Соответственно с помощью класса XMLEncoder, можно легко восстановить потом объект из XML-файла.

Эти проблемы были решены созданием классов и интерфейсов библиотеки Swing с использованием одного только языка Java.

Компоненты AWT являются тяжеловесными, в то время как компоненты Swing являются легковесными.

Библиотека AWT использует нативный код (код, специфичный для конкретной операционной системы) для отображения компонентов.

Каждая реализация среды выполнения Jave Runtime Environment должна обеспечивать собственные реализации кнопок, меток, панелей и всех других компонентов AWT.

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

Это позволяет использовать кнопку AWT в приложении, но кнопка отображается как кнопка Windows, или кнопка Mac или другая кнопка конкретной платформы, на которой работает приложение.

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

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

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

Например, когда Java рисует метку, она не просто рисует строку в нужном месте на экране.

Она создает пир и помещает его на экран.

В свою очередь компоненты Swing используют пиры для двух задач.

Во-первых, Swing компоненты JFrame, JWindow, JDialog и JApplet расширяют свои AWT-аналоги.

И все они используют пиры для отображения фактической области рисования на экране.

Другие компоненты Swing легковесные; у них нет пиров.

Эти компоненты отрисовывают себя поверх существующих JFrame, JWindow, JDialog или JApplet.

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

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

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

Далее, наличие нативного кода значительно затрудняет перенос Java на новую платформу.

Проще говоря, хотя сам язык Java был кросс-платформенным, библиотека AWT была его ахиллесовой пятой.

Наконец, нативные пиры потребляют много ресурсов.

Можно было бы ожидать, что использование нативного кода будет намного более эффективным, чем создание компонентов на Java.

Тем не менее, для создания большого количества элементов GUI может потребоваться много времени, когда для каждого из них требуется создание его пира.

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

Легковесный компонент – это просто компонент, полностью реализованный на Java.

Для создания легковесного компонента достаточно расширить AWT класс Component или Container напрямую, реализуя внешний вид компонента на Java, а не делегируя внешний вид пиру.

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

Вы реализуете весь внешний вид, используя методы paint и update, и вы реализуете поведение компонента, улавливая пользовательские события и, возможно, генерируя новые события.

В библиотеке AWT для создания совершенно нового компонента вам нужно было бы расширять класс Canvas.

Легковесному компоненту достаточно расширить класс Component или Container.

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

Вместо этого Toolkit создает для компонента объект LightweightPeer, который служит как указатель и идентифицирует компонент как легковесный.

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

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

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

Метод setBackground легковесного компонента, просто расширяющего класс Component, не работает, так как всю работу по изображению кнопки на экране выполняет не peer-двойник компонента, а тяжеловесный контейнер, в котором расположен компонент.

Контейнер ничего не знает о том, что надо обратиться к методу setBackground, он рисует только то, что записано в методе paint.

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

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

Предпочтительный размер тяжеловесного компонента устанавливается peer-объектом, поэтому для легковесных компонентов его надо задать явно, переопределив метод getPreferredSize, иначе некоторые менеджеры компоновки, например FlowLayout (), установят нулевой размер, и компонент не будет виден на экране.

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

Таким образом, на основе библиотеки AWT, появилась библиотека Swing – Java-библиотека классов и интерфейсов, представляющих такие стандартные графические компоненты интерфейса пользователя как кнопки, таблицы, поля ввода и др., а также методы для работы с ними.

Библиотека Swing составляет основную часть библиотеки JFC (Java Foundation Classes), которая объединяет классы и интерфейсы, обеспечивающие интерфейс пользователя Swing-компонентами, выбор внешнего вида и поведения интерфейса, поддержку технологий для людей с ограниченными возможностями, работу с высококачественной двухмерной графикой, текстом и изображениями, а также интернационализацию графического интерфейса пользователя.

В настоящее время библиотека Swing входит в набор настольных Java-технологий.

Все классы Swing-компонентов являются наследниками базового класса JComponent пакета javax. swing.

При конструировании Swing-интерфейса компоненты помещаются в контейнеры, образующие иерархию, которая берет свое начало от контейнеров верхнего уровня, представленных классами JApplet, который уже запрещен, JDialog, JFrame и JWindow.

Основные свойства графической библиотеки Swing можно суммировать как:

Кроссплатформенность.

Механизм сменного внешнего вида и поведения компонентов (pluggable look and feel).

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

Расширяемость за счет возможности расширения классов и интерфейсов библиотеки.

Архитектура Swing-компонентов основана на технологии Java Beans.

Возможность настройки внешнего вида Swing-компонентов за счет изменения свойств таких элементов компонентов как рамки, цвет, фон и др.

Легковесность.

Так как AWT-компоненты непосредственно взаимодействуют с операционной системой и представляют собой каждый маленькое индивидуальное окно, то их называют тяжеловесными.

Компоненты Swing представляют собой области в окне, характеризующиеся координатами и размером, при этом они не работают напрямую с операционной системой, их отображение основывается на реализации Java 2D API, поэтому их называют легковесными.

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

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

Использование библиотеки Swing не является потоково-безопасной.

Доступ к Swing-компонентам должен осуществляться в специальном потоке Event Dispatch Thread (EDT).

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

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

Возможность настройки текста, отображаемого Swing-компонентами с помощью HTML-тэгов.

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

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

Возможность отображения иконок Swing-компонентами.

Реализация модели MVC (Model-View-Controller) – модели отделения данных от внешнего вида и поведения интерфейса.

Многие Swing-компоненты имеют связанные с ними интерфейсы (Model), которые отвечают за доступ к данным и генерацию событий, связанных с изменением данных.

Архитектура MVC (модель – вид – контроллер) – это объектно-ориентированная архитектура пользовательских интерфейсов, состоящая из трех частей.

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

Вид представляет данные на экране.

Контроллер обеспечивает реакцию модели и вида в ответ на действия пользователя.

Архитектура MVC реализована в библиотеке Swing в виде архитектуры с разделенной моделью, состоящей из двух, а не из трех частей.

Вид и контроллер, в архитектуре Swing, объединены вместе в один элемент – представителя пользовательского интерфейса (delegate UI).

Класс графического компонента связывает модель и представителя с помощью менеджера пользовательского интерфейса (UIManager), который определяет внешний вид и поведение интерфейса (Look and Feel).

Именно поэтому библиотека Swing имеет подключаемую архитектуру look-and-feel.

Таким образом, для реализации модели MVC библиотека Swing использует делегирование (delegation) полномочий, назначая в качестве модели данных представителя (delegate) – экземпляр класса с именем вида xxxModel.

Класс библиотеки Swing содержит защищенное или даже закрытое поле model – объект этого класса-модели, и метод getModel, предоставляющий разработчику доступ к полю model.

Для обеспечения внешнего вида и поведения Swing компонента также используется делегирование полномочий.

Swing класс JComponent содержит защищенное поле ui – экземпляр класса-представителя ComponentUI из пакета javax.swing.plaf, непосредственно отвечающего за вывод изображения на экран в нужном виде.

Класс-представитель содержит методы paint и update, формирующие и обновляющие графику компонента.

Такие представители образуют целую иерархию с общим суперклассом ComponentUI.

Они собраны в пакет javax.swing.plaf и его подпакеты.

В их именах есть буквы UI (User Interface), например, ButtonUI.

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

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

В большинстве случаев достаточно обращаться к методам самого класса компонента.

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

Новая модель данных устанавливается методом setModel (xxxModel).

Для создания графического интерфейса пользователя с использованием библиотеки Swing в среде разработки IntelliJ IDEA, нужно нажать правой кнопкой мышки на пакете приложения и выбрать New – GUI Form.

Ввести имя класса и нажать OK.

В результате будет создан Java класс и его XML описание с расширением. form, которое открывается в визуальном редакторе, позволяя визуально создавать и редактировать GUI интерфейс.

Первоначально форма состоит только из контейнера JPanel.

Для дальнейшей работы с GUI интерфейсом, нужно в поле field name ввести имя этого компонента.

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

Далее нужно открыть связанный с формой Java класс и в коде класса нажать правой кнопкой мыши и выбрать Generate – Form main ().

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

А именно, будет сгенерирован метод main, в котором будет создано окно верхнего уровня JFrame.

И в это окно будет добавлена панель формы.

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

При этом по умолчанию в Java класс будут добавляться только соответствующие поля.

Весь остальной код будет генерироваться сразу в байт-код при компиляции на основании XML файла описания формы.

Изменить это можно в настройках File | Settings | Editor | GUI Designer, выбрав опцию Java source code.

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

Для добавления слушателя к компоненту, нужно нажать правой кнопкой мыши на компоненте и выбрать Create Listener.

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

Если у вас есть поля в Swing компоненте, которые вы хотите связать с данными класса JavaBean, нужно нажать правой кнопкой мыши на компоненте и выбрать Data Binding Wizard.

Дальше следовать подсказкам.

В результате будет сгенерирован Plain Old Java Object класс.

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

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

Для этого нужно нажать на поле Client Properties.

И открыть окно свойств.

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

С выбранным классом в левой панели нажмите кнопку + на правой панели.

И добавьте свойство.

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

Также можно добавить значок в кнопку.

Компонент JLabel может отображать либо текст, либо изображение, либо и то, и другое.

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

Компонент JLabel используется для отображения одной строки только для чтения.

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

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

Использовать компонент JColorChooser очень просто.

Вызываем статический метод showDialog, который отображает модальное диалоговое окно выбора цвета.

Это диалоговое окно блокирует приложение до тех пор, пока оно не будет закрыто.

В метод showDialog передается цвет выбора по умолчанию.

Пользователь может в диалоге изменить этот цвет выбора.

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

Щелчок мыши на флажке изменяет его состояние с «on» на «off» и наоборот.

Методом setMnemonic можно определить горячие клавиши для этой кнопки.

А флажок является кнопкой, так как наследует от класса AbstractButton.

Компонент JRadioButton используется для создания переключателя.

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

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

Для того чтобы выбор кнопки был единственным, кнопки нужно объединить в группу ButtonGroup.

Если это не сделать, выбор будет множественным.

Компонент JToggleButton реализует функции переключения, которые наследуются компонентами JCheckBox и JRadioButton.

Компонент JToggleButton используется для создания кнопок с двумя состояниями – включен и выключен.

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

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

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

Создать экземпляр раскрывающегося списка можно конструктором по умолчанию JComboBox, а затем вносить в него элементы методами addItem (Object) и insertItemAt (Object, int).

Однако удобнее предварительно создать массив или вектор, содержащий элементы, и внести его в список сразу же при его создании конструктором JComboBox (Object []) или JComboBox (Vector).

Получить элемент списка, который выбрал пользователь, можно с помощью метода getSelectedIndex или getSelectedItem.

Вместо строк, список можно составить из изображений, или других объектов.

Список становится редактируемым с помощью вызова метода setEditable (true).

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

Редактирование выбранного элемента списка не приводит к изменению этого элемента в списке, а влияет только на объект, возвращаемый методом getSelectedItem.

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

Здесь нужно учитывать, что слушатель ActionListener получает событие ActionEvent, когда был сделан выбор.

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

Таким образом, обработчик ActionListener вызывается два раза.

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

Для изображения элементов списка используется объект, реализующий интерфейс ListCellRenderer.

Этот объект последовательно выводит элементы, переходя от одного элемента к другому.

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

Метод getListCellRendererComponent интерфейса ListCellRenderer отвечает за формирование компонента и размещения в нем текущего элемента списка value, имеющего порядковый номер index.

Полученный таким образом компонент затем выводится на экран своим методом paint.

В библиотеке Swing интерфейс ListCellRenderer реализован классами BasicComboBoxRenderer и DefaultListCellRenderer, расширяющими класс JLabel.

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

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

Когда размер экрана ограничен, используется панель прокрутки для отображения большого компонента или компонента, размер которого может изменяться динамически.

Полосы прокрутки могут всегда отображаться на экране, отображаться при необходимости или не отображаться вообще. Это определяется методами setVerticalScrollBarPolicy и setHorizontalScrollBarPolicy.

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

Эти компоненты устанавливаются методами setColumnHeaderView, setRowHeaderView и setCorner соответственно.

Компонент помещается на панель прокрутки сразу же при ее создании конструктором класса JScrollPane или позднее методом setViewportView.

На самом деле компонент отображается в панели прокрутки в окне содержимого JViewport, которое содержит панель JScrollPane.

Это окно можно получить методом getViewport класса JScrollPane, а затем можно добавить в него компонент обычным методом add.

Список можно создать с помощью конструктора по умолчанию JList, создающего пустой список.

Можно создать список с заданным массивом объектов конструктором JList (Object []), или с заданным вектором при помощи конструктора JList (Vector) или с определенной заранее моделью JList (ListModel).

Это делается так же, как и при создании выпадающего списка JComboBox.

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

При этом метод setVisibleRowCount задает число видимых на экране строк.

Значение по умолчанию равно 8.

Вызов этого метода с отрицательным значением эквивалентно значению нуль.

Метод setLayoutOrientation определяет компоновку элементов списка.

Константа VERTICAL определяет расположение элементов вертикально в одном столбце.

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

Константа VERTICAL_WRAP определяет расположение элементов по вертикали, при необходимости с переносом их в новый столбец.

В сочетании с вызовом метода setLayoutOrientation, вызов метода setVisibleRowCount (-1) делает список отображающим максимальное количество элементов в доступном пространстве на экране.

Методами setFixedCellHeight и setFixedCellWidth можно установить высоту и ширину отображаемых строк списка.

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

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

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

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

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

Вы можете обработать эти события, добавив в список слушатель с помощью метода addListSelectionListener.

Слушатель выбора списка должен реализовать один метод valueChanged.

Метод getValueIsAdjusting возвращает true, если пользователь все еще выбирает в списке.

Так как нам нужен только конечный результат действия пользователя, метод valueChanged делает что-либо, только если getValueIsAdjusting возвращает false.

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

MVC – это общий подход к построению графических приложений.

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

Эта идея исходит из того, что мы хотели бы иметь более одного способа посмотреть на одни и те же данные.

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

Еще один пример из реляционных баз данных.

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

Поэтому архитектура MVC предлагает нам строить графические интерфейсы с помощью моделей, видов и контроллеров.

Модель является источником данных, а вид – это Представление данных.

Модель ничего не знает вообще о Представлениях.

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

Таким образом, Представление является просто наблюдателем модели.

Когда данные в Модели меняются, она генерирует событие, отражающее изменение.

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

Хорошо, где Контроллер в этой картине?

Контролер отвечает за изменение модели.

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

Обычно Контроллер состоит из графической части и некоторой логики приложения.

Например, вы хотите добавить меню в свой редактор.

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

Теперь, добавляя меню, вы делаете его частью своего контроллера.

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

Контроллер – это способ, которым пользователь меняет модель.

Контроллер не обновляет Представление, потому что оно автоматически получает обновления, как наблюдатель модели.

Давайте теперь посмотрим на пример MVC.

Рассмотрим модель SimpleStringModel, которая будет иметь один контроллер и несколько видов.

В этой модели у нас есть два метода getString и setString.

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

Соответственно объект модели хранит список своих слушателей.

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

Представление имеет метод setModel, в котором Представление становится слушателем Модели.

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

Контроллер здесь текстовое поле, в которое пользователь вводит строку текста, и эта строка становится новым значением Модели.

Этот базовый пример иллюстрирует, как реализуется архитектура MVC.

Еще одна интересная и очень полезная функция, которую мы получаем, когда используем MVC.

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

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

Swing реализация MVC объединяет Controller и View представление.

На самом деле это не очень сложно сделать.

Вы просто размещаете функции View представления и Сontroller в одном классе.

В предыдущем примере у нас было два графических компонента – один для Представления, а второй для Контоллера.

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

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

Давайте посмотрим, как реализована архитектура MVC в Swing на примере списка.

Давайте посмотрим на интерфейс ListModel, представляющий модель данных списка.

Во-первых, этот интерфейс легковесный, так как в нем нет ссылки на сам список.

Во-вторых, этот интерфейс присоединяет слушателя модели, как задумано в MVC.

И есть способ получения данных модели, с помощью методов size/get, что гораздо лучше, чем использование метода, например, возвращающего массив данных, так как при использовании методов size/get не занимается память под массив данных, не происходит копирование данных.

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

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

Так как модель данных ListModel, как и все модели MVC, добавляет в качестве слушателя список, список на экране уведомляется каждый раз, когда происходят изменения модели.

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

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

Теперь, еще одной очень полезной концепцией является отфильтрованная модель.

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

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

Таким образом, происходит фильтрация данных модели.

Еще одна полезная концепция – это слияние моделей.

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

Опять же это делается с помощью методов size/get без копирования данных исходных моделей.

Таким образом, есть много интересных вещей, которые мы можем делать с моделями.

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

Например, JList позволяет пользователю определить ListCellRenderer, который является небольшим классом, который заботится о том, как конкретный элемент списка будет визуализирован.

Этот интерфейс имеет только один метод getListCellRendererComponent.

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

Это полезно по нескольким причинам.

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

И список не знает, как отобразить произвольный объект как String.

Вы можете думать о СellRenderer как об адаптере, который знает, как адаптировать объект к строке.

Как вы видите в этом примере, фактический список содержит учеников, а не строки, которые отображаются.

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

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

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

Здесь реальный источник данных – это список java.util.List.

И этот адаптер использует этот список в своих методах size/get.

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

Еще одно преимущество, которое мы получаем от использования объекта ListCellRenderer, заключается в том, что мы можем представлять разные ячейки по-разному.

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

Методом setFont можно изменить шрифт текста.

Методом setText можно установить текст поля, а методом getText получить его.

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

Метод setHorizontalAlignment позволяет изменить выравнивание текста по умолчанию по левому краю.

Выключить редактирование текста можно методом setEditable (false).

Метод setCaretColor позволяет изменить цвет курсора.

Позицию курсора можно отследить методом getCaretPosition, или установить методом setCaretPosition.

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

Цвет выделенного текста можно задать методом setSelectedTextColor, а цвет фона выделенного текста методом setSelectionColor.

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

Для решения этих задач придется расширить компонент JTextField, переопределяя его методы focusGained и focusLost, а также реализуя интерфейс DocumentListener с определением метода insertUpdate.

Компонет JPasswordField предназначен для ввода пароля и позволяет редактировать одну строку текста.

Класс JPasswordField расширяет класс JTextField, и отличается от него тем, что в этом поле вместо вводимых символов повторяется один символ, по умолчанию – звездочка.

Звездочку можно заменить другим символом с помощью метода setEchoChar.

Второе отличие заключается в том, что вместо метода getText для получения текста из поля пароля используется метод getPassword, возвращающий массив символов типа char, а не строку.

По умолчанию реализация обеспечивает форматированный вывод объектов типа Number и Date в виде строки.

Метод getValue возвращает объект типа Object, полученный в результате обратного преобразования отредактированной в окне строки в первоначальный объект.

Преобразованием объекта в строку и обратно занимается вложенный в JFormattedTextField абстрактный класс AbstractFormatter.

Библиотека Swing предоставляет реализации этого класса – классы DateFormatter, NumberFormatter и MaskFormatter.

Мы можем создать компонент JFormattedTextField с помощью объекта форматирования.

Для этого можно использовать классы DateFormatter, NumberFormatter и MaskFormatter для форматирования даты, числа и строки, соответственно.

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

Шрифт текста устанавливается методом setFont.

Введенный текст можно получить методом getText.

Установить текст методом setText, или добавить текст методом append, или вставить текст методом insert.

По умолчанию компонент JTextArea не обеспечивает возможность прокрутки большого текста.

Поэтому компонент нужно поместить в контейнер JScrollPane.

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

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

Для переноса слова целиком и слов на новую строку нужно применить методы setWrapStyleWord (true) и setLineWrap (true).

По умолчанию этот компонент может отображать и редактировать простой текст, документ HTML и Rich Text Format (RTF).

В случае HTML, компонент JEditorPane может отображать HTML-документ, соответствующий спецификации Html 3.2 с ограниченной поддержкой css и без поддержки Javascript.

В этом примере мы создаем компонент JEditorPane и помещаем его в окно JFrame.

Метод setContentType класса JEditorPane устанавливает тип содержимого для обработки редактором.

При этом вызывается метод getEditorKitForContentType, а затем метод setEditorKit.

Компонент JEditorPane использует реализации EditorKit редакторов для текстового содержимого определенного типа.

Здесь мы устанавливаем отображение и редактирование HTML контента.

Далее мы создаем меню для загрузки контента в компонент JEditorPane.

Контент в виде строки загружается методом setText.

Также можно использовать метод setPage для загрузки контента по URL адресу.

В этом примере мы также создаем меню для переключения типа содержимого с HTML на простой текст и обратно.

Если вы нажмете команду Plain в меню View, содержимое будет отображаться в виде обычного текста, как исходный HTML-код.

При этом надо отметить, что вызов метода setContentType фактически удаляет текущий текстовый контент в области редактора.

Вот почему мы сначала сохраняем содержимое в переменной.

Также при переключении на обычный текст, исходный HTML код модифицируется.

В частности, удаляются inline css стили.

Чтобы сделать JEditorPane доступным только для чтения, нужно использовать метод setEditable (false).

При отображении HTML-документа, компонент JEditorPane может обнаруживать HTML-ссылки и отвечать на клики пользователей.

Чтобы обрабатывать событие click на ссылках, нужно обработать событие HyperlinkEvent, присоединив слушателя методом addHyperlinkListener.

Здесь показан пример реализации обработки гиперссылок.

Сначала мы проверяем, является ли обрабатываемое событие событием активации, а не событием входа (клика) или выхода (готовности).

Затем мы проверяем, является ли обрабатываемое событие событием активации HTML фрема.

И если это так, тогда мы открываем фрейм с помощью HTMLDocument.

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

Обратите внимание, если тип содержимого является HTML документ, тогда относительные ссылки, например, для таких вещей, как изображения, не могут быть разрешены, если не используется тег <base> или не указан абсолютный путь изображения.

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

Компонент JTextPane дополняет JEditorPane возможностью работать с объектом StyledDocument.

Реализация DefaultStyledDocument позволяет легко добавить новые стили методом addStyle.

Можно задать атрибуты для отдельных символов методом setCharacterAttributes.

Можно задать атрибуты сразу целому элементу методом setParagraphAttributes.

Можно вставить в текущую позицию текста изображение методом insertIcon.

Также можно вставить любой компонент методом insertComponent.

Значок – это объект, который реализует интерфейс Icon.

Swing обеспечивает реализацию интерфейса Icon – класс ImageIcon, который создает значок из изображения формата GIF, JPEG или PNG.

Надо отметить, что в библиотеке Swing нет класса, заменяющего AWT класс Image, есть только класс ImageIcon, который используется для декорирования компонентов значками.

Здесь показано создание значка из изображения, расположенного в пакете приложения, и установка этого значка на панели главного окна приложения.

Он создает модальные или немодальные диалоговые окна.

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

Каждое диалоговое окно обязательно связано с родительским AWT окном Window, Dialog или Frame.

Диалоговое окно снабжено рамкой и строкой заголовка, в которую помещается строка, записанная в конструкторе.

В строке заголовка есть кнопка Закрыть, реакцию на которую, а заодно и реакцию на нажатие комбинации клавиш <Alt> + <F4>, можно установить методом setDefaultCloseOperation.

Модальность окна и его заголовок можно изменить методами setModalityType и setTitle.

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

Как уже говорилось ранее, Swing предоставляет контейнеры верхнего уровня: JFrame, JDialog и JWindow.

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

При этом каждый GUI компонент может содержаться только один раз.

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

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

Вы можете дополнительно добавить панель меню в контейнер верхнего уровня.

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

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

Панель содержимого по умолчанию – это простой промежуточный контейнер, который наследуется от JComponent и использует BorderLayout в качестве менеджера компоновки.

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

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

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

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

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

Здесь слоистая панель layered pane содержит панель меню и панель содержимого и обеспечивает упорядочивание других компонентов по оси Z.

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

Здесь показан пример создания пользовательского диалога.

В конструкторе класса используется панель содержимого для создания интерфейса диалога.

Также переопределяется метод createRootPane, который создает корневую панель, для закрытия диалога при нажатии кнопки «Escape».

В этом методе используется метод getKeyStroke класса KeyStroke для установки нажатия клавиши ESCAPE.

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

Таким образом определенные KeyStroke и AbstractAction используются в созданной корневой панели JRootPane.

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

Во входной карте мы устанавливаем нажатие клавиши «ESCAPE».

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Класс 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 расширяет класс Window библиотеки AWT и является тяжеловесным компонентом.

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

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

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

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

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

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

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

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

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

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

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

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

Они помещаются в одну очередь и обрабатываются одним потоком – 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 является абстрактным классом.

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

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

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

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

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

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

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

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

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

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

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

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

Класс 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 отображается самостоятельно.

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

Если это время больше, чем 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.

Панель меню представлена классом JMenuBar.

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

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

Выбор меню представлен классом JMenu, а опция в списке представлена классом JMenuItem.

При этом видно, что класс JMenu расширяет класс JMenuItem.

Чем же отличаются выбор меню от опции в списке?

Во-первых, видно, что и тот и другой класс, это просто кнопки.

Но, выбор меню JMenu, в отличие от опции JMenuItem, обеспечивает всплывающее окно, содержащее JMenuItems, которое отображается, когда пользователь выбирает JMenu в панеле JMenuBar.

В дополнение к элементам JMenuItem, меню JMenu также может содержать разделители JSeparator.

По сути, меню представляет собой кнопку с ассоциированным всплывающим меню JPopupMenu.

Когда нажимается «кнопка», появляется всплывающее меню JPopupMenu.

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

Затем создается само меню, которое добавляется в панель меню методом add.

Так как панель меню использует компоновку BoxLayout, а метод add позволяет добавлять любой Swing компонент, в панель меню можно добавить заполнитель класса Box, и меню окажется справа.

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

Элементы меню добавляются в меню методом add.

Туда же можно и добавлять разделители между элементами меню.

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

Также, при создании элемента меню можно задать для него горячие клавиши, методом setAccelerator.

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

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

Для меню и элементов меню можно назначить мнемонику или клавиши выбора с помощью метода setMnemonic.

Здесь для меню File мы назначаем комбинацию клавиш Alt + F, при нажатии на которые открывается меню.

Затем мы назначаем мнемонику или клавишу Е для элемента меню Exit.

Чтобы воспользоваться этой клавишей, мы сначала нажимаем Alt + F, то есть открываем меню, а затем нажимаем E и срабатывает этот элемент меню.

В отличие от мнемоники, клавиши акселерации сразу нажимают элемент меню.

Меню и элемент меню также можно создать на основе объекта Action, инкапсулирующего свойства, которые могут быть повторно использованы.

Объект Action может быть использован для разделения функциональности и состояния от самого компонента.

Например, если у вас есть два или более компонента, которые выполняют одну и ту же функцию, можно использовать один объект Action для создания этих компонентов.

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

Состояние, которое обрабатывается этим действием, включает в себя текст, значок, мнемонику, активацию и выбранный статус.

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

Далее мы создаем элемент меню на основе объекта Action и добавляем этот элемент в само меню.

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

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

В этом примере мы создаем две радиокнопки и объединяем их в группу.

Чтобы могла быть выбрана только одна кнопка.

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

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

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

Затем создаются элементы меню, которые добавляются в всплывающее меню.

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

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

Всплывающие меню запускаются по-разному на разных платформах.

Поэтому событие isPopupTrigger следует проверять как в методе mousePressed, так и в методе mouseReleased для правильной межплатформенной функциональности.

В компоненте JList и JComboBox пользователь может выбирать ввод из заданного набора значений.

Компонент JSpinner также позволяет использовать этот тип выбора.

Другая половина компонента JSpinner – это форматированное поле JFormattedTextField.

В компоненте JSpinner, как отображать или вводить значение не контролируется средством отображения списка ListCellRenderer, как в JList.

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

Так как для ввода и отображения в компоненте JSpinner у нас есть форматированное поле JFormattedTextField, мы имеем три предустановленных типа ввода – это список строк, последовательность объектов Number, и последовательность объектов Date.

Для создания компонента JSpinner, сначала создается его модель данных.

Предустановленные модели данных – это SpinnerDateModel, SpinnerListModel, и SpinnerNumberModel.

Эти классы расширяют абстрактный класс AbstractSpinnerModel.

Поэтому, если вы хотите создать свою собственную модель данных, вам нужно создать свою собственную реализацию абстрактного класса AbstractSpinnerModel.

Здесь показано создание модели SpinnerListModel.

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

Далее вы создаете компонент JSpinner на основе модели данных.

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

Компонент JSpinner напрямую поддерживает один тип прослушивателя событий – это ChangeListener.

Этот слушатель уведомляется, когда вызывается метод commitEdit, сообщая, что значение счетчика изменилось.

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

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

Для этого вам нужно обратиться к вспомогательному классу компонента JSpinner.

Для каждой из моделей данных компонента JSpinner, доступен вспомогательный класс ListEditor, DateEditor, NumberEditor, которые расширяют базовый класс DefaultEditor.

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

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

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

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

Здесь мы выравниваем значение по центру поля ввода.

Если вы хотите отображать в спиннере даты, вам нужно использовать модель данных SpinnerDateModel.

Здесь в конструкторе модели мы указываем текущее значение, начальное и конечное значения последовательности дат, ограничивая диапазон 100 годами.

Последним аргументом конструктора вы указываете шаг изменения даты.

Соответственно, в слушателе изменения свойства поля ввода, вы должны проверять, является ли вводимое значение объектом класса Date.

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

Затем вы должны установить этот редактор для спиннера методом setEditor.

Модель данных SpinnerNumberModel обеспечивает выбор номера из открытого или закрытого диапазона значений.

Это число может быть любым из подклассов класса Number, включая объекты Integer и Double.

Здесь в конструкторе модели мы также указываем текущее значение, начальное и конечное значения последовательности чисел, указывая шаг изменения значения.

В слушателе изменения свойства поля ввода, вы должны проверять, является ли вводимое значение объектом класса Number.

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

Затем вы должны установить этот редактор для спиннера методом setEditor.

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

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

Рядом с линейкой ползунка можно разметить шкалу со штрихами, отстоящими друг от друга на расстояние, устанавливаемое методом setMajorTickSpacing.

После определения расстояния шкала отображается методом setPaintTicks (true).

К штрихам можно добавить отображение числовых значений методом setPaintLabels (true).

Между штрихами можно отобразить более мелкие штрихи методом setMinorTickSpacing.

Если применить метод setSnapToTicks (true), то ползунок будет останавливаться только против штрихов.

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

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

Методом createStandardLabels можно изменить это правило, задав другой шаг расстановки чисел на шкале и другой начальный отсчет.

Затем эту таблицу нужно установить на шкале методом setLabelTable.

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

После этого эта таблица устанавливается методом setLabelTable для ползунка.

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

Дерево содержит один корневой объект root, далее размещаются его потомки узловые объекты node, имеющие своих потомков и одного предка parent.

На самом нижнем уровне расположены листья leaf – узлы, не имеющие потомков.

Как и все Swing компоненты, компонент JTree использует отдельный объект модели для хранения и представления данных, которые он отображает.

Большинство компонентов Swing автоматически создают этот объект модели, и вам не нужно явно с ним работать.

Однако компонент JTree отображает данные, которые намного сложнее, чем данные типичного компонента Swing.

Когда вы работаете с JTree, вы должны явно использовать объект модели.

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

Следующие три конструктора создают дерево без объекта корневого узла.

Полноценное дерево вы можете создать, передав в конструктор модель данных, реализующую интерфейс TreeModel.

Существует класс DefaultTreeModel, реализующий этот интерфейс.

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

Поэтому для дерева JTree предусмотрен конструктор, который создает дерево сразу на основе корневого узла.

Корневой узел – это объект, реализующий интерфейс TreeNode.

Существует класс DefaultMutableTreeNode, реализующий этот интерфейс.

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

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

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

Здесь мы создали дерево строк.

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

Одно условие – объект должен иметь метод toString, возвращающий строку, которая и будет отображаться на экране в дереве.

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

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

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

И дальше уже с этим объектом работать.

Вы также можете редактировать текст в каждом узле, вызвав метод setEditable (true) для дерева.

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

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

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

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

Значение узла и будет новым отредактированным значением.

Помимо присоединения слушателя, модель данных DefaultTreeModel позволяет вставить узел в дерево с помощью метода insertNodeInto и удалить узел из дерева с помощью метода removeNodeFromParent.

За редактирование дерева отвечает редактор TreeCellEditor, который можно получить методом getCellEditor.

TreeCellEditor – это интерфейс.

Реализация этого интерфейса по умолчанию – это класс DefaultTreeCellEditor, к объекту которого можно присоединить слушатель редактирования узла CellEditorListener.

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

Свой редактор DefaultTreeCellEditor можно создать с помощью конструктора, в котором указывается дерево, объект DefaultTreeCellRenderer, отвечающий за отображение дерева, и редактор DefaultCellEditor, отвечающий за редактирование узла дерева.

В свою очередь редактор DefaultCellEditor можно создать на основе флажка, выпадающего списка и текстового поля (по умолчанию).

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

Если для создания дерева не устраивает предоставленная по умолчанию модель данных DefaultTreeModel, вы создаете свою, реализуя интерфейс TreeModel.

Если не устраивает предоставленный по умолчанию редактор, вы создаете свой, реализуя интерфейс TreeCellEditor.

Если не устраивает отображение узлов, вы реализуете интерфейс TreeCellRenderer.

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

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

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

По умолчанию, пользователь может выбирать только файлы.

Чтобы пользователь смог выбрать также и каталог, нужно вызвать метод setFileSelectionMode с константой FILES_AND_DIRECTORIES.

По умолчанию JFileChooser не отображает скрытые файлы.

Чтобы установить их отображение, нужно вызвать метод setFileHidingEnabled (false).

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

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

По умолчанию JFileChooser показывает все файлы в выбранном каталоге.

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

Фильтр файлов представлен абстрактным классом FileFilter.

Можно напрямую реализовать этот класс, определив его метод accept, принимает ли фильтр этот файл, и метод getDescription, описание фильтра.

Или можно использовать готовую реализацию – класс FileNameExtensionFilter.

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

Полученный фильтр устанавливается с помощью метода addChoosableFileFilter.

Можно создать несколько фильтров и добавить их в JFileChooser.

Тогда пользователь сможет выбирать фильтр в выпадающем списке.

По умолчанию в JFileChooser добавляется фильтр All Files.

Чтобы его убрать, используется метод setAcceptAllFileFilterUsed (false).

В компонент JFileChooser можно добавить Swing компонент с помощью метода setAccessory.

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

В этом примере мы создаем класс, расширяющий класс JComponent, в котором мы присоединяем слушатель изменения свойства к JFileChooser.

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

Компонент JTable использует модель данных таблицы TableModel для управления фактическими данными таблицы, модель TableColumnModel, содержащую список столбцов таблицы, и модель выбора строк таблицы ListSelectionModel.

Компонент JTable использует редактор ячеек таблицы TableCellEditor, рендерер TableCellRenderer для отображения ячеек на экране, класс TableColumn для хранения информации о свойствах каждого столбца.

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

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

Для создания таблицы предлагается несколько конструкторов.

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

Конструктор JTable (int rows, int columns) формирует пустую редактируемую таблицу с заданным числом строк и столбцов с моделью данных по умолчанию, которая предполагает хранить в таблице объекты типа Object в виде вектора типа Vector, состоящего из векторов.

Конструктор JTable (Object [] [] data, Object [] colNames) создает таблицу, заполненную объектами data.

Параметр colNames содержит имена столбцов таблицы.

Все строки массива data должны содержать столько же элементов, сколько существует в массиве colNames.

Конструктор JTable (Vector data, Vector colNames) делает то же самое, но параметры заданы векторами.

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

Однако эти конструкторы также имеют недостатки.

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

Они обрабатывают все типы данных одинаково, как строки.

Например, если столбец таблицы имеет логические данные, таблица может отображать данные в виде флажка.

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

Кроме-того, при изменении данных, придется заново создавать таблицу, с новыми массивами.

Остальные конструкторы определяют таблицу с заранее заданными моделями данных.

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

Надо заметить, что заголовки столбцов появляются на экране, только если таблица заключена в панель JScrollPane.

Если при этом у столбцов не заданы имена, то они помечаются буквами A, B, C и т. д., как принято в электронных таблицах.

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

При вызове метода setFillsViewportHeight (true), таблица использует всю высоту контейнера, даже если таблица не имеет достаточного количества строк для использования всего вертикального пространства.

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

Чтобы настроить начальную ширину столбцов, вы можете вызвать метод setPreferredWidth для каждого столбца таблицы.

Столбец таблицы получается из модели TableColumnModel, которая получается методом getColumnModel.

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

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

Режим выбора устанавливается методом setSelectionMode на основе констант MULTIPLE_INTERVAL_SELECTION, SINGLE_INTERVAL_SELECTION, и SINGLE_SELECTION.

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

Эта модель получается методом getSelectionModel для таблицы.

По умолчанию вы получаете модель выбора строк.

Чтобы получить модель выбора столбцов, вы должны сначала вызвать метод getColumnModel, а затем метод getSelectionModel.

Также, по умолчанию, обработчик слушателя вызывается дважды – при нажатии клавиши мыши и при ее отпускании.

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

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

Как уже было сказано, по умолчанию, пользователь выбирает строку.

Чтобы пользователь мог выбрать одну ячейку, используется метод setCellSelectionEnabled (true).

Выбор столбца пользователем также можно отследить с помощью слушателя события изменения модели столбца TableColumnModel, который добавляется методом addColumnModelListener.

Модель столбца TableColumnModel отвечает за добавление или удаление столбцов, их перестановку, и выделение столбцов.

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

Чтобы отделить данные от таблицы, используется модель данных TableModel.

Модель хранения содержимого ячеек таблицы описана интерфейсом TableModel, который частично реализован абстрактным классом AbstractTableModel и полностью реализован его подклассом DefaultTableModel.

Если программист не предоставляет объект модели таблицы, компонент JTable автоматически создает экземпляр DefaultTableModel.

Поэтому использование модели DefaultTableModel по сути ничем не отличается от использования простых конструкторов класса JTable.

DefaultTableModel – это реализация интерфейса TableModel, которая использует вектор векторов для хранения объектов значений ячейки.

Предположим, мы хотим отобразить в таблице не просто строки, а произвольные объекты, например, экземпляры класса User.

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

Или объект должен быть совсем простым, с одним полем и методом toString, который возвращает значение этого поля.

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

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

Можно также выполнять операции над полями и методами, которые исследуются.

Рефлексия в Java осуществляется с помощью программного интерфейса Java Reflection API.

Этот интерфейс API состоит из классов пакетов java.lang и java.lang.reflect.

С помощью интерфейса Java Reflection API можно определить класс объекта.

Получить информацию о модификаторах класса, полях, методах, конструкторах и суперклассах.

Выяснить, какие константы и методы принадлежат интерфейсу.

Создать экземпляр класса, имя которого неизвестно до момента выполнения программы.

Получить и установить значение свойства объекта.

Вызвать метод объекта.

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

Итак, для каждого типа объектов, во время выполнения виртуальная машина Java создает экземпляр класса java.lang.Class, который предоставляет методы для исследования свойств объекта, включая его поля и информацию о типе.

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

Получить объект типа Class можно методом getClass из объекта любого класса.

Если у нас есть экземпляр объекта Class, мы можем получить всевозможную информацию об этом классе и даже осуществлять операции над ним.

Метод getClass часто полезен тогда, когда есть экземпляр объекта, но не известно какого класса этот экземпляр.

После получения объекта Class, мы можем получить имя класса с помощью метода getName.

Объект типа String, возвращаемый методом getName, будет содержать полностью уточненное имя класса, включая пакет, то есть, например, для Integer – это будет java.lang.Integer.

Чтобы узнать, какие модификаторы были применены к классу, сначала нужно с помощью метода getClass получить объект типа Class, представляющий данный класс.

Затем нужно вызвать метод getModifiers для объекта типа Class, чтобы определить значение типа int, биты которого представляют модификаторы класса.

После этого можно использовать статические методы класса java.lang.reflect.Modifier, чтобы определить, какие именно модификаторы были применены к классу.

Метод getTypeParameters позволяет получить дженерик параметры класса.

Метод getGenericInterfaces позволяет получить реализованные интерфейсы класса.

Метод getSuperclass позволяет получить объект суперкласса.

Чтобы исследовать поля, принадлежащие классу, можно воспользоваться методом getFields для объекта типа Class.

Метод getFields возвращает массив объектов типа java.lang.reflect.Field, соответствующих всем публичным полям объекта.

С помощью класса Field можно получить имя поля, тип и модификаторы.

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

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

Чтобы получить значение поля, нужно сначала получить для этого поля объект типа Field затем использовать метод get.

Метод принимает входным параметром ссылку на объект класса.

Для установки значения поля, используется метод set.

Чтобы получить информацию о публичных конструкторах класса, нужно вызвать метод getConstructors для объекта Class.

Этот метод возвращает массив объектов типа java.lang.reflect.Constructor.

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

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

Чтобы получить информацию о публичных методах класса, нужно вызвать метод getMethods для объекта Class.

Этот метод возвращает массив объектов типа java.lang.reflect.Method.

Затем с помощью объекта Method можно получить имя метода, тип возвращаемого им значения, типы параметров, модификаторы и генерируемые исключения.

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

Java Reflection Api позволяет динамически вызвать метод, даже если во время компиляции имя этого метода неизвестно.

Если метод имеет модификатор доступа private, тогда для получения доступа к методу нужно вызвать для него метод setAccessible (true).

С помощью метода newInstance объекта Class можно динамически загружать и создавать экземпляры класса.

Менеджер компоновки отвечает за расположение компонентов внутри контейнера.

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

Менеджер компоновки – это объект, который реализует интерфейс LayoutManager и определяет размер и положение компонентов в контейнере.

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

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

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

Указав вместо экземпляра менеджера значение null, вы можете работать вообще без менеджера компоновки и размещать каждый компонент индивидуально в контейнере, указывая размеры и местоположение компонента с помощью метода setBounds класса java.awt.Component.

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

Менеджер компоновки вычисляет минимальные / предпочтительные / максимальные размеры контейнера.

И далее размещает компоненты в контейнере.

Менеджеры компоновок делают это на основе предоставленных ограничений, таких как свойств контейнера и минимальных / предпочтительных / максимальных размеров компонентов.

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

Контейнер может быть действительным, а именно, его метод isValid возвращает true, или недействительным.

Чтобы контейнер был действительным, все его компоненты контейнера должны быть расположены и все они должны быть действительными.

Метод Container.validate может использоваться для проверки недопустимого контейнера.

Этот метод запускает менеджер компоновки для контейнера и всех дочерних контейнеров вниз по иерархии компонентов и маркирует этот контейнер как действительный.

При изменении размера контейнера ряды компонентов перестраиваются.

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

В каждом ряду компоненты могут прижиматься к левому краю, если в конструкторе первый аргумент равен FlowLayout. LEFT, к правому краю, если этот аргумент FlowLayout. RIGHT, или собираться в середине ряда, если FlowLayout. CENTER – по умолчанию.

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

Эти же параметры можно изменить методами setHgap, setVgap, и setAlignment.

Эти области получили географические названия – NORTH, SOUTH, WEST, EAST и CENTER.

Метод add контейнера в случае применения BorderLayout имеет два аргумента: ссылку на компонент и область, в которую помещается компонент.

Метод add с одним аргументом помещает компонент в область CENTER.

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

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

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

Если не занята область CENTER, тогда компоненты прижимаются к границам контейнера.

Так как менеджер компоновки BorderLayout размещает не больше пяти компонентов, можно использовать в качестве компонентов панели, в которые дополнительно размещать компоненты.

Все компоненты получают одинаковый размер.

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

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

Компоненты размещаются менеджером GridLayout слева направо по строкам созданной таблицы в том порядке, в котором они заданы в методах add контейнера.

Нулевое количество строк или столбцов означает, что менеджер сам создаст нужное их число.

Остальные компоненты лежат под первым в определенном порядке.

Их расположение определяется порядком добавления в контейнер с помощью метода add.

Следующий компонент можно показать методом next менеджера, предыдущий – методом previous, последний – методом last, первый – методом first.

Аргумент этих методов – ссылка на контейнер, в который помещены компоненты.

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

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

Метод add тогда имеет в качестве аргумента имя компонента.

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

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

В классе GridBagLayout есть только один конструктор, конструктор по умолчанию, без аргументов.

Менеджер GridBagLayout, в отличие от других менеджеров компоновки, не содержит правил размещения. Он играет только организующую роль.

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

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

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

Класс GridBagConstraints содержит одиннадцать полей, определяющих размеры компонентов, их положение в контейнере и взаимное положение, и несколько констант – значений полей.

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

Здесь поле gridx указывает номер строки, поле gridy указывает номер столбца, поле gridwidth указывает количество занимаемых ячеек в строке, поле ipady указывает сколько добавляется к минимальной высоте компонента, поле fill используется, когда область отображения компонента больше, чем размер компонента.

Это означает, что каждый компонент должен быть определен дважды в горизонтальной и вертикальной компоновке.

Если вы забудете это сделать, GroupLayout выбросит исключение.

Менеджер GroupLayout использует два типа размещения компонентов: последовательное и параллельное расположение.

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

Позиция каждого компонента определяется относительно предыдущего компонента.

Второй способ размещает компоненты параллельно – поверх друг друга в одном и том же месте.

Компоненты могут быть выровнены по базовой линии, по верху или низу по вертикали.

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

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

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

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

Отступы произвольного размера могут быть добавлены к группам компонентов, как отдельные компоненты, с помощью методов для групп GroupLayout.ParallelGroup и GroupLayout.SequentialGroup.

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

Метод setAutoCreateGaps устанавливает, должен ли автоматически создаваться промежуток между компонентами при последовательном размещении.

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

Метод setHorizontalGroup создает горизонтальную группу компонентов, а метод setVerticalGroup создает вертикальную группу компонентов, при этом мы определяем, какая это будет группа – с последовательным размещением компонентов или параллельным размещением.

Для определения типа группы используются методы createSequentialGroup и createParallelGroup.

Метод addComponent добавляет компонент в группу, а метод addGroup добавляет группу.

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

По горизонтальной оси кнопки 2 и 3 занимают одно и тоже место, поэтому эта группа будет параллельной.

И в нее мы добавляем кнопки 2 и 3.

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

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

Менеджер компоновки BoxLayout создается с помощью конструктора, первым параметром которого указывается контейнер.

Второй параметр задает способ расположения компонентов в этом контейнере с помощью одной из констант X_AXIS – расположение слева направо, Y_AXIS – расположение сверху вниз, LINE_AXIS и PAGE_AXIS – расположение определяется контейнером.

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

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

Панель Box – это контейнер, который использует менеджер компоновки BoxLayout.

Вы можете легко создавать сложные компоновки компонентов, помещая их в несколько вложенных ящиков Box.

Панель Box создается с помощью статического метода createHorizontalBox для горизонтального размещения компонентов или статического метода createVerticalBox для вертикального размещения компонентов.

Класс Box также предоставляет статические методы, которые создают невидимые компоненты, которые можно использовать для улучшения компоновки.

Их можно даже использовать в контейнерах, которые не являются панелями Box, например, в панели JPanel.

Вы можете отдельно управлять выравниванием каждого компонента, вызывая следующие методы setAlignmentX, выравнивание о оси х от центра контейнера, и setAlignmentY, выравнивание по оси y, которые компонент наследует от класса Component.

strut- это невидимый компонент, который имеет фиксированный размер в пикселях.

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

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

Он полезен для сохранения ориентации компонентов в контейнере по мере его изменения.

glue создается с помощью статического метода createGlue.

Разделительная область (rigid area) – это невидимый компонент с фиксированной шириной и высотой.

Этот компонент создается с помощью статического метода createRigidArea.

Кроме этих трех компонентов-разделителей можно использовать невидимый компонент с фиксированным минимальным, максимальным и предпочтительным размерами.

Он является объектом класса Filler, вложенного в класс Box.

Например, вы можете определить, что левый край одного компонента является фиксированным расстоянием (например, 5 пикселей) от правого края другого компонента.

В SpringLayout положение каждого края зависит от положения только одного другого края.

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

В отличие от многих менеджеров компоновки SpringLayout автоматически не устанавливает местоположение своих компонентов.

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

Края компонента привязываются с помощью объектов SpringLayout.Constraints.

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

Объект Constraints имеет свойства x, y, width и height.

Однако в объекте Constraints эти свойства имеют значения Spring вместо целых чисел.

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

Объект Spring имеет четыре свойства – минимальное, предпочтительное и максимальное значения и фактическое (текущее) значение.

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

Таким образом, компоновку SpringLayout можно представить, как набор объектов, которые соединены множеством пружин на их краях.

В этом примере мы устанавливаем ограничения методом putConstraint для менеджера SpringLayout.

В которых мы связываем левый край метки с левым краем контейнера.

Верхний край метки с верхним краем контейнера.

Левый край поля с правым краем метки.

Правый край поля с правым краем контейнера.

И нижний край поля с нижним краем контейнера.

Эти два компонента могут располагаться по горизонтали, что определяется константой HORIZONTAL_SPLIT класса JSplitPane, или по вертикали – константа VERTICAL_SPLIT.

Эти константы указываются в конструкторе класса JSplitPane.

Конструктор по умолчанию JSplitPane без аргументов задает горизонтальное расположение компонентов и создает, и размещает две кнопки JButton с надписями «left button» и «right button».

Панель JSplitPane при перемещении разделительной черты может перерисовывать компоненты сразу же по мере передвижения или после окончательной установки разделительной черты.

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

Остальные конструкторы класса JSplitPane кроме расположения задают два компонента панели.

Очень часто компоненты, размещаемые на панели, – это панели прокрутки JScrollPane, содержащие текст, изображение, таблицу или другие компоненты.

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

Его можно установить методом setDividerLocation.

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

По умолчанию толщина равна 8 пикселов.

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

На разделительную черту можно поместить две небольшие кнопки с треугольными стрелками методом setOneTouchExpandable (true).

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

Компоненты можно установить на панель или заменить другими компонентами с помощью методов setLeftComponent, setRightComponent, setTopComponent, setBottomComponent.

При этом остальные компоненты лежат под первым в определенном порядке.

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

Конструктор по умолчанию класса JTabbedPane создает пустую панель без вкладок.

Первый аргумент конструктора задает расположение вкладок с помощью констант TOP, BOTTOM, LEFT, RIGHT.

Как правило, вкладки помещаются сверху (TOP), но, их можно поместить снизу, слева и справа.

Если все вкладки не помещаются в окно панели в один ряд, тогда они могут располагаться несколькими рядами или прокручиваться, для чего в строке вкладок появляются кнопки прокрутки.

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

Расположение вкладок в несколько рядов устанавливается константой WRAP_TAB_LAYOUT, расположение вкладок в один ряд с прокруткой устанавливается константой SCROLL_TAB_LAYOUT.

Для добавления компонентов в панель используется метод add или метод addTab, в котором можно указать строку заголовка вкладки, разместить объект или иконку на вкладке, определить всплывающую подсказку для вкладки.

Все это можно сделать также методами set класса JTabbedPane.

Вставить вкладку можно также методом insertTab.

Кроме того, можно задать цвет фона вкладки методом setBackgroundAt.

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

И вам самостоятельное задание – создайте панель JTabbedPane с кнопками, закрывающими вкладки панели.

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

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

Пустая горизонтальная панель создается конструктором по умолчанию класса JToolBar.

В конструкторе можно задать расположение панели – горизонтальное расположение – это константа HORIZONTAL, вертикальное – константа VERTICAL.

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

При применении метода setRollover (true) кнопки панели выделяются при наведении курсора.

При использовании метода setFloatable (false), панель становится неперемещаемой.

Метод add класса JToolBar также позволяет добавить в панель объект Action.

Интерфейс Action расширяет интерфейс ActionListener и используется в случаях, когда к одной и той же функциональности можно обращаться несколькими элементами управления.

В дополнение к методу actionPerformed, определенному интерфейсом ActionListener, этот интерфейс позволяет приложению определять в одном месте клавиши мнемоники и акселерации, значки и строки, используемые меню и кнопками.

Интерфейс Action частично реализован абстрактным классом AbstractAction, в котором не определен только метод actionPerformed.

Поэтому для создания объекта Action достаточно расширить класс AbstractAction, определив этот метод.

Некоторые контейнеры, такие как JMenu, JPopupMenu и JToolBar, умеют использовать объекты, реализующие интерфейс Action.

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

Например, метод add панели инструментов JToolBar создаст инструментальную кнопку JButton с изображением, командной клавишей, всплывающей подсказкой и прочими свойствами, содержащимися в объекте Action.

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

Границы или стороны прямоугольника могут быть выделены каким-то образом на экране.

Библиотека Swing позволяет изменить оформление границ любого компонента, обведя его рамкой разного вида.

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

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

Чтобы разместить рамку вокруг компонента JComponent, используется метод setBorder, который в качестве аргумента принимает объект Border.

Интерфейс Border описывает общие свойства всех рамок.

Его метод paintBorder отвечает за рисование рамки для указанного компонента с указанным положением и размером.

Рамка может быть прозрачной или не прозрачной. Это определяется логическим методом isBorderOpaque.

Последний метод интерфейса, getBorderInsets, возвращает пространство, занятое рамкой данного компонента, в виде экземпляра класса Insets.

В классе Insets это пространство определяется толщиной рамки сверху, слева, справа и снизу.

Интерфейс Border частично реализован абстрактным классом AbstractBorder, в котором определена пустая реализация метода paintBorder, метод isBorderOpaque возвращает false, а метод getBorderInsets – возвращает объект с нулевыми значениями.

Кроме этих реализаций в классе AbstractBorder есть метод getInteriorRectangle, который удобно использовать для определения размеров самого компонента без рамки.

Класс AbstractBorder расширяют около двадцати классов, рисующие разные рамки.

Для удобства работы с ними имеется класс BorderFactory, в котором собраны статические методы вида createXxxBorder () для различных типов рамок с разными параметрами.

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

Класс EmptyBorder представляет самую простую рамку.

Это пустое пространство, окружающее компонент.

Класс LineBorder определяет одноцветную рамку заданной толщины, одинаковой на всех сторонах рамки.

Первый аргумент задает цвет рамки, второй аргумент задает толщину рамки и третий аргумент создает рамку с закругленными краями.

Рамка BevelBorder состоит из двух линий: светлой и темной.

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

Это тип RAISED, он указывается как первый аргумент.

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

Это тип LOWERED.

Класс SoftBevelBorder расширяет класс BevelBorder, создавая рамки со слегка закругленными, смягченными краями.

Класс EtchedBorder создает объемную рамку врезанную или вдавленную в контейнер в зависимости от типа.

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

Аргументами метода служат размеры рамки в пикселях и изображение или цвет.

Класс TitledBorder позволяет создать рамку с надписью.

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

Однако надпись можно вставить в рамку любого типа.

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

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

Первым аргументов указывается внешняя рамка, а вторым аргументом указывается внутренняя рамка.

Рамка DashedBorder представляет собой пунктирную линию.

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

Свою рамку можно создать, расширив какой-либо класс рамок или расширив абстрактный класс AbstractBorder.

Класс графического Swing компонента связывает модель и представителя с помощью менеджера пользовательского интерфейса (UIManager), который определяет внешний вид и поведение интерфейса (Look and Feel).

Именно поэтому библиотека Swing имеет подключаемую архитектуру look-and-feel.

Вид (look) каждого графического компонента задают его форма, тип и цвет рамки, цвет фона, цвет, тип и размер шрифта, форма курсора мыши.

Поведение компонента (feel) определяют та или иная реакция на действия мыши, набор командных клавиш, способ перемещения окон и т. д.

Таким образом, для реализации модели MVC библиотека Swing использует делегирование (delegation) полномочий, назначая в качестве модели данных представителя (delegate) – экземпляр класса с именем вида xxxModel.

Класс библиотеки Swing содержит защищенное или даже закрытое поле model – объект этого класса-модели, и метод getModel, предоставляющий разработчику доступ к полю model.

Для обеспечения внешнего вида и поведения Swing компонента также используется делегирование полномочий.

Swing класс JComponent содержит защищенное поле ui – экземпляр класса-представителя ComponentUI из пакета javax.swing.plaf, непосредственно отвечающего за вывод изображения на экран в нужном виде.

Класс-представитель содержит методы paint и update, формирующие и обновляющие графику компонента.

Такие представители образуют целую иерархию с общим суперклассом ComponentUI.

Они собраны в пакет javax.swing.plaf и его подпакеты.

В их именах есть буквы UI (User Interface), например, ButtonUI.

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

Таким образом, каждый компонент имеет UI-делегата, который отвечает за внешний вид и поведение интерфейса (Look and Feel).

Класс UIManager имеет статический метод с именем getUI.

Когда создается какой-либо Swing компонент, он вызывает этот метод для получения UI-делегата.

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

UIManager содержит текущий внешний вид и поведение в виде объекта LookAndFeel, который определяет сопоставления между идентификаторами классов и UI-делегатами в хэш-таблице UIDefaults.

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

LookAndFeel – это абстрактный базовый класс для всех классов внешнего вида и поведения.

Каждая реализация LookAndFeel должна обеспечивать реализацию соответствующего подкласса ComponentUI или UI-делегата, указав значение для каждого из идентификаторов классов Swing компонентов в объекте UIDefaults, который возвращается методом getDefaults LookAndFeel.

Теперь, как установить внешний вид и поведение?

Во-первых, если вы собираетесь установить L & F программным способом, вы должны сделать это как самый первый шаг в своем приложении.

В противном случае вы рискуете инициализировать L & F по умолчанию независимо от того, какой L & F вы затем запросили.

Это может произойти непреднамеренно, когда статическое поле ссылается на класс Swing, что приводит к загрузке L & F по умолчанию.

Как уже было сказано, связующим звеном между компонентом и внешним видом является менеджер UIManager.

При этом класс UIManager хранит доступные L&F в виде массива объектов вложенного класса UIManager. LookAndFeelInfo.

Посмотреть все доступные L&F можно с помощью метода getInstalledLookAndFeels класса UIManager.

Задать один из доступных L&F можно с помощью статического метода setLookAndFeel класса UIManager.

Аргумент этого метода – это строка, содержащая полное имя нужного класса LookAndFeel со всеми подпакетами.

При динамическом изменении L&F нужно в слушателе UIManager вызвать метод updateComponentTreeUI класса SwingUtilities.

В аргументе этого метода нужно указать контейнер верхнего уровня, и этот метод рекурсивно просмотрит все вложенные контейнеры и компоненты, и для каждого компонента установит новый L&F.

Во время работы приложения можно заменить не весь текущий L&F, а только некоторые его свойства.

Для этого нужно использовать статический метод put класса UIManager.

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

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

Пакет Synth Look and Feel служит оболочкой LookAndFeel (skinnable look and feel) и предназначен для создания новых пользовательских LookAndFeel с помощью XML-файла.

Это дает возможность создать новый внешний вид без написания нового графического Java-пакета, что является очень трудоемким делом, так как для создания нового подкласса LookAndFeel требуется расширение каждого из классов уже существующих пакетов LookAndFeel (базовый пакет BasicLookAndFeel состоит из 60 классов).

Для того чтобы создать новый внешний вид с помощью пакета Synth Look and Feel, создадим экземпляр этого класса и методом load загружается набор свойств, определяющих внешний вид графических компонентов.

Метод getResourceAsStream класса java.lang.Class ищет ресурсы, ассоциированные с указанным классом, и возвращает входящий поток, связанный с XML ресурсом, относительное имя которого указано в аргументе метода load.

Второй аргумент метода load определяет локализацию ресурсов, упоминаемых в XML файле, например, файлов изображений.

В коде XML файла элемент <synth> является корневым и содержит все остальные элементы, определяющие SynthLookAndFeel.

Элемент <style> содержит элементы, описывающие свойства дизайна, такие как цвет, шрифт, размер и др. Его атрибут id определяет уникальный идентификатор для данного стиля.

Элемент <font> устанавливает шрифт со следующими основными атрибутами: id – идентификатор; name – название шрифта; style – стиль шрифта; size – размер шрифта в пикселях.

Элемент <state> устанавливает визуальные свойства компонента, связанные с его указанным состоянием.

Элемент имеет следующие основные атрибуты: id – идентификатор состояния; value – указывает состояние компонента, с которым связываются визуальные свойства, может принимать значения ENABLED, MOUSE_OVER, PRESSED, DISABLED, FOCUSED, SELECTED или DEFAULT (если значение не указано, визуальные свойства связываются со всеми состояниями компонента).

Элемент <color> устанавливает цвет со следующими основными атрибутами: id – идентификатор цвета; type – определяет, в какой части компонента применяется данный цвет, может принимать значения FOREGROUND, BACKGROUND, TEXT_FOREGROUND, TEXT_BACKGROUND или FOCUS; value – значение, определяющее цвет.

Элемент <bind> устанавливает, для какого компонента или региона применяется указанный стиль.

Регион – это индивидуальное визуальное пространство Swing компонента.

Регионы компонентов представляет класс javax.swing.plaf.synth.Region.

Компонент может поддерживать один или несколько регионов.

Например, кнопка поддерживает один регион BUTTON, а панель прокрутки – три: панель прокрутки SCROLL_BAR, ползунок прокрутки SCROLL_BAR_THUMB и полосу прокрутки SCROLL_BAR_TRACK.

Элемент <bind> имеет следующие атрибуты: style – идентификатор стиля, который связывается с компонентом или регионом; type – принимает два значения region (стиль связывается с именем региона) или name (стиль связывается с именем компонента); key – определяет имя региона или имя компонента.

Элемент <insets> увеличивает размеры компонента или региона, к которому применяется стиль.

Атрибуты элемента top, bottom, left и right устанавливают увеличение размеров в пикселях в четырех направлениях.

Элемент <imagePainter> регистрирует объект класса javax.swing.plaf.synth.SynthPainter для данного стиля или состояния, при этом указанный в элементе метод класса SynthPainter визуализирует заданное ресурсное изображение.

Атрибут id определяет идентификатор элемента, method – задает метод класса SynthPainter для визуализации изображения, direction – определяет ориентацию изображения, path – указывает относительный адрес изображения.

Атрибуты center и sourceInsets устанавливают два различных режима визуализации изображения.

Если указан атрибут center=«true», то заданное изображение прорисовывается по центру региона или компонента, сохраняя свои исходные размеры.

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

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

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

Атрибут paintCenter определяет, будет или нет, прорисована центральная часть изображения.

С помощью элемента <painter> можно зарегистрировать расширение класса SynthPainter для данного стиля или состояния.

В нашем случае, вначале мы задаем стиль по умолчанию для всех компонентов приложения с помощью атрибута «key=». *»».

Этот стиль определяет шрифт и цвет текста всего графического интерфейса.

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

С помощью элемента insets увеличиваются размеры региона TEXT_FIELD – объекта класса javax.swing.plaf.synth.Region.

Для кнопок графического интерфейса задаются стили для трех состояний:

Все состояния кнопки, за исключением кнопка «нажата» или на нее навели мышку.

Состояние – кнопка «нажата».

Состояние – на кнопку навели мышку.

Для элементов меню переопределяется шрифт.

Для панели меню указывается фоновое изображение.

Стиль региона PANEL включает в себя фоновое изображение и изображение рамки.

Включается она методом setDragEnabled (true).

Перенос данных с помощью мыши (Drag and Drop) или командных клавиш (Cut-Copy-Paste) обеспечивает передачу данных между компонентами в приложении и между вашим приложением и другими приложениями.

Когда начинается перетаскивание данных (Drag and Drop), компонент упаковывает данные для экспорта и объявляет, какие действия он как источник данных поддерживает, такие как COPY, MOVE или LINK.

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

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

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

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

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

И наконец, целевой компонент импортирует данные.

Здесь показан пример списка и текстовой области, в которую можно перетаскивать из списка, после применения метода setDragEnabled (true).

Если вы хотите контролировать перетаскивание данных, вам нужно использовать метод setTransferHandler и свой класс TransferHandler.

Класс TransferHandler предоставляет простой механизм для передачи данных в JComponent и из него – все детали содержатся в этом классе и его поддерживающих классах.

Большинство компонентов снабжены обработчиком передачи TransferHandler по умолчанию.

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

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

Здесь мы создаем объект TransferHandler с помощью конструктора, в котором указываем Java Bean свойство компонента, используемое для переноса данных.

Помним, что Swing компоненты является Java Bean компонентами и их свойства можно получить с помощью интерфейса Java Bean API, а именно класса BeanInfo.

Здесь используется свойство text метки.

Установкой объекта TransferHandler для метки мы включаем перенос текста в метку.

Для включения переноса текста из метки, мы присоединяем слушателя событий мыши к метке, и в обработчике нажатия клавиши мыши на источнике данных, в данном случае это метка, мы применяем к объекту TransferHandler метод exportAsDrag, который переносит данные из источника данных.

Для создания собственного Swing компонента нужно расширить класс JComponent, переопределив его метод paintComponent.

Метод paintComponent – это место, где должен быть размещен весь код рисования компонента.

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

Но на самом деле рисование компонента начинается выше в иерархии классов вызовом метода paint AWT класса Component.

Далее метод paint вызывает поочередно методы paintComponent, paintBorder и paintChildren класса JComponent.

Как уже было сказано, большинство стандартных компонентов Swing имеют внешний вид, реализованный отдельными делегатами пользовательского интерфейса.

Это означает, что рисование стандартных компонентов Swing происходит следующим образом.

Метод paint вызывает paintComponent.

Если свойство ui не равно null, то есть для компонента есть делегат, мето paintComponent вызывает метод ui. update.

Если свойство компонента opaque истинно, метод ui. update заполняет фон компонента цветом и вызывает метод ui.paint.

Метод ui.paint отображает содержимое компонента.

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

Другой способ декорировать существующий Swing компонент – это использовать компонент JLayer.

JLayer – это универсальный декоратор для компонентов Swing, который позволяет реализовывать различные расширенные эффекты рисования, а также получать уведомления обо всех AWT событиях.

Компонент JLayer делегирует рисование и обработку входных событий объекту LayerUI.

То есть компонент JLayer служит оберткой вокруг существующего Swing компонента, передавая функциональность рисования и обработки событий объекту LayerUI.

Таким образом, для рисования на существующем Swing компоненте, нужно создать класс, расширяющий класс LayerUI, и реализующий его метод paint.

Затем нужно создать компонент JLayer на основе существующего Swing компонента и объекта LayerUI.

scene.control,

scene.chart,

scene.image,

scene.layout,

scene.media,

scene.shape,

scene.canvas,

scene. text,

scene. web и

stage.

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

Пакет scene.control предоставляет такие компоненты графического интерфейса пользователя как панель Accordion, кнопку Button, переключатель CheckBox, список ChoiceBox, выбор цвета ColorPicker, выпадающий список ComboBox, выбор даты DatePicker, контекстное меню ContextMenu, гиперссылку Hyperlink, метку Label, список ListView, меню Menu, панель MenuBar, кнопку MenuButton, постраничную навигацию Pagination, поле PasswordField, индикатор ProgressBar, индикатор ProgressIndicator, переключатель RadioButton, панель ScrollPane, прокрутку ScrollBar, разделитель Separator, бегунок Slider, кнопку SplitMenuButton, панель SplitPane, таблицу TableView, панель TabPane, поле TextArea, поле TextField, панель TitledPane, кнопку ToggleButton, группу ToggleGroup, панель ToolBar, окно Tooltip, таблицу TreeTableView, дерево TreeView.

Пакет scene.chart обеспечивает создание диаграмм AreaChart, BarChart, BubbleChart, LineChart, PieChart, ScatterChart, StackedAreaChart, StackedBarChart.

Пакет scene.image предоставляет компоненты изображения ImageView и WritableImage.

Пакет scene.layout предоставляет панели компоновки AnchorPane, BorderPane, FlowPane, GridPane, HBox, StackPane, TilePane, VBox.

Пакет scene.media предоставляет компоненты медиаконтента MediaView и аудиоконтента AudioClip.

Пакет scene.shape обеспечивает рисование 2D геометрических форм с помощью таких компонентов как Arc, Circle, CubicCurve, Ellipse, Line, Path, Polygon, Polyline, QuadCurve, Rectangle, SVGPath, а также 3D графики с помощью таких GUI-компонентов как Box, Cylinder, MeshView, Sphere.

Пакет scene.canvas позволяет с помощью классов Canvas и GraphicsContext создавать изображения 2D-графики из простых геометрических форм, из существующих изображений и текста.

Пакет scene. text предоставляет компоненты текста Text и TextFlow.

Пакет scene. web обеспечивает отображение HTML-контента с помощью компонента WebView и редактирование HTML-контента с помощью компонента HTMLEditor.

Пакет scene предоставляет группу Group и сцену Scene, а также камеры ParallelCamera и PerspectiveCamera и источники света AmbientLight и PointLight.

Пакет stage предоставляет компоненты окон Stage, Popup, DirectoryChooser и FileChooser.

Пакеты embed. swing и embed. swt обеспечивают встраивание JavaFX компонентов в Swing (и наоборот) и SWT приложения.

Пакет css позволяет определять пользовательские свойства и CSS псевдо классы для компонентов.

Пакет print обеспечивает печать узла графа JavaFX сцены.

Пакет fxml обеспечивает декларативное XML описание GUI-компонентов.

Пакет scene. effect позволяет присоединять к GUI-компонентам визуальные эффекты смешивания, свечения, тени, размытия, цвета, смещения, освещения, перспективы, отражения, старения.

Пакет animation позволяет добавлять трансформации и анимации для GUI-компонентов.

Отображение 2D графики в JavaFX-приложениях возможно тремя способами:

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

Далее пакет scene.image с помощью класса ImageView обеспечивает отображение существующего изображения, загружаемого с помощью класса Image.

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

И пакет scene.canvas обеспечивает создание узла графа сцены Canvas с последующим рисованием в нем простых геометрических форм, заполнение Canvas-узла изображением и текстом.

Если сравнивать JavaFX 2D графику с 2D графикой библиотек AWT/Swing, можно сказать, что, если не вдаваться в детали различающихся моделей программирования, JavaFX 2D графика обеспечивает ту же функциональность, что и AWT/Swing 2D графика, упрощая добавление к объектам 2D графики визуальных эффектов, трансформаций и анимации.

Надо также отметить, что в отличие от AWT/Swing, JavaFX предоставляет для использования готовые 2D примитивы в виде узлов графа сцены, в то время как в AWT/Swing их нужно рисовать.

Отображение 3D графики в JavaFX-приложениях возможно двумя способами.

Первый способ – это создание 2D объекта графа сцены и применение к нему 3D трансформаций.

Второй способ – использование классов Box, Cylinder, MeshView, Sphere пакета scene.shape, представляющих готовые Shape3D графические примитивы куб, цилиндр, поверхность и сфера.

При этом узлы Shape3D графа сцены имеют такие свойства как материал, режим рисования и отображение внутренних поверхностей.

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

Если сравнивать JavaFX 3D графику с 3D графикой библиотеки Java 3D, можно сказать, что, если не вдаваться в детали различающихся моделей программирования, JavaFX 3D графика обеспечивает ту же функциональность, что и Java 3D графика, за исключением использования класса Canvas3D библиотеки Java 3D, позволяющего 3D рисование.

Теперь перечислим основные возможности JavaFX.

JavaFX предоставляет программный интерфейс JavaFX API для создания на языке Java JavaFX-приложений с богатым GUI-интерфейсом, 2D/3D графикой, анимацией и аудио-видео контентом.

JavaFX интегрирована с JRE/JDK.

JavaFX имеет альтернативное декларативное XML-описание GUI-интерфейса на языке FXML.

JavaFX включает инструмент JavaFX Scene Builder для визуальной компоновки GUI-компонентов в GUI-интерфейс на основе языка FXML.

JavaFX обеспечивает изменение внешнего вида GUI-компонентов с использованием CSS.

JavaFX обеспечивает встраивание HTML-контента в JavaFX-приложение с помощью компонента WebView с возможностью выполнения Javascript-кода и редактирование HTML-контента с помощью компонента HTMLEditor.

JavaFX обеспечивает интеграцию с библиотеками Swing и SWT.

JavaFX обеспечивает создание красочных и насыщенных отчетов с диаграммами данных.

JavaFX предоставляет богатый набор компонентов и компоновок компонентов для создания GUI-интерфейса.

JavaFX обеспечивает встраивание аудио и видео контента в JavaFX-приложение с помощью компонентов MediaView и AudioClip.

JavaFX обеспечивает отображение 2D и 3D графики с добавлением визуальных эффектов, трансформаций и анимации.

JavaFX обеспечивает создание изображений 2D-графики из простых геометрических форм, из существующих изображений и текста с помощью Canvas API.

JavaFX обеспечивает поддержку Rich Text с помощью пакета javafx.scene. text.

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

JavaFX позволяет печать узла графа JavaFX сцены с помощью Printing API.

JavaFX обеспечивает связывание данных.

JavaFX позволяет выполнение фоновых задач.

JavaFX позволяет разделение сцены на подсцены с помощью SubScene API.

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

Это 2D-графика – создание цифровых изображений из двухмерных геометрических моделей.

Растровая графика – это представление цифрового изображения в виде сетки пикселей.

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

И наконец 3D-графика – создание цифровых изображений из трехмерного представления геометрических данных.

Рендеринг (rendering) – это процесс генерации растрового изображения из модели (model) или сцены (scene) с сопутствующими эффектами.

Одним из быстрых методов рендеринга является растеризация (rasterisation) – геометрическое проецирование моделей на плоскость изображения с генерацией растрового изображения.

Рендеринг, основанный на растеризации, выполняется по графическому конвейеру (graphics pipeline).

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

Тесселяция (tessellation) – процесс разбиения поверхности модели на полигоны, он производится программным обеспечением без аппаратного ускорения.

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

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

Наиболее распространенные технологии графического конвейера – это библиотеки OpenGL и Direct3D.

Модель – это описание или набор данных, представляющий форму объекта.

В JavaFX-технологии модель представлена экземпляром класса GUI-компонента.

Сцена – это скомпонованный в рабочей области набор моделей и объектов, вызывающих различные эффекты, например, источник света и камера, которые создают эффекты освещенности и перспективы.

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

Полигон (polygon) – замкнутая фигура, созданная путем соединения отрезков, где каждый конец отрезка соединяется только с одним концом двух других отрезков (треугольник, прямоугольник, окружность и т.д.). Отрезки называются краями или сторонами (edges или sides), а точки соединения отрезков – вершинами (vertices).

Растровое изображение модели, интегрированное в сцену, называется спрайтом (sprite).

Такой рендеринг называется предварительным (pre-rendering) – когда используются предварительно сгенерированные изображения моделей перед отображением всей сцены в реальном времени.

Граф сцены (scene graph) – это структура данных, коллекция узлов (node) дерева, которая упорядочивает логическую структуру сцены.

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

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

Ключевой кадр (key frame) – указывает значение свойства в определенное время в период выполнения анимации.

Анимация создается с помощью изменения таких свойств объектов как размер, положение, цвет и т. д.

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

Материал – это информация о характеристиках поверхности 3D-объекта – цвет, отражающая/преломляющая способность и др.

Mesh – это набор вершин и многоугольников, определяющих форму 3D-объекта.

Back-face culling – отключение отображения невидимых поверхностей.

В то время как библиотеки AWT/Swing и SWT оперируют окнами, в которых размещаются компоненты интерфейса согласно компоновкам, компоненты графического интерфейса пользователя JavaFX-приложения образуют сцену, логическая структура которой описывается графом сцены.

Отображением интерфейса JavaFX-приложения является графическое представление графа сцены.

Каждый узел графа JavaFX-сцены – это компонент графического интерфейса пользователя – имеет такие свойства как идентификатор, CSS-стиль, границы, визуальные эффекты, прозрачность, трансформации, обработчики событий, состояние, режим наложения и участие в анимации.

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

Prism – производит растеризацию и рендеринг JavaFX-сцен с использованием аппаратного ускорения и на основе программного обеспечения – технологии DirectX 9 – для Windows XP и Windows Vista, DirectX 11 – для Windows 7 и OpenGL – для Mac, Linux, Embedded.

При отсутствии поддержки аппаратного ускорения рендеринг осуществляется на основе технологии Java2D.

Glass Windowing Toolkit – это платформо-зависимая реализация, связывающая платформу JavaFX с операционной системой компьютера.

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

В отличие от графической системы Abstract Window Toolkit (AWT), которая создает свою собственную очередь событий и два потока – один для работы Peer-компонентов, а другой для работы Java-компонентов, система Glass использует очередь событий операционной системы и работает в том же потоке, что и JavaFX-приложение.

При этом основной поток JavaFX-приложения отличается от AWT и Swing потока Event Dispatch Thread (EDT).

Quantum Toolkit – связывает системы Prism и Glass вместе и делает их доступными для других модулей среды выполнения JavaFX Runtime.

Media Engine – обеспечивает воспроизведение MP3, AIFF и WAV аудиофайлов и FLV видеофайлов.

Web Engine – основывается на проекте WebKit и обеспечивает поддержку HTML5, CSS, JavaScript, DOM и SVG, отображение локального и удаленного HTML-контента, обновление и редактирование HTML-контента с поддержкой истории и навигации, обработку событий, выполнение JavaScript-кода и применения эффектов.

Для обеспечения работы JavaFX-приложения среда выполнения JavaFX Runtime создает следующий набор параллельных потоков:

Основной поток JavaFX-приложения JavaFX Application Thread – отвечает за обновление сцены, обработку анимации и событий.

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

Фоновый медиа поток – отвечает за декодирование, буферизацию и воспроизведение аудио и видео.

Синхронизация графа сцены с его графическим представлением осуществляется с помощью событий Pulse, которые генерируются средой выполнения JavaFX Runtime с максимальной частотой 1/60 секунды и посылаются в очередь событий при анимации и всякий раз, когда изменяется граф сцены, вызывая перерисовку сцены с применением компоновок и стилей.

Модель программирования приложений платформы JavaFX

Точкой входа в JavaFX-приложение служит Java-класс, расширяющий абстрактный класс javafx. application. Application и содержащий его переопределенный метод start.

Главный класс JavaFX-приложения должен переопределить абстрактный метод start класса Application, обеспечивающий создание и отображение сцены JavaFX-приложения.

Методы init, start и stop класса Application являются методами обратного вызова жизненного цикла JavaFX-приложения.

Методы init и stop класса Application могут использоваться для инициализации данных и освобождения ресурсов JavaFX-приложения.

Метод launch класса Application запускает настольное приложение в методе main.

Вызов метода launch класса Application инициализирует среду выполнения JavaFX.

При этом среда выполнения JavaFX выполняет следующие действия.

Она создает экземпляр класса приложения, вызывает его метод init.

Далее вызывает метод start.

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

Приложение вызывает метод Platform. exit.

Класс Platform пакета application является вспомогательным классом.

Последнее окно приложения закрывается, и атрибут implicitExit класса Platform имеет значение true.

После этого среда выполнения вызывает метод stop.

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

Методы init и stop имеют конкретные реализации, которые ничего не делают.

Вызов метода Platform. exit – это предпочтительный способ явно закрыть приложение JavaFX.

Непосредственный вызов обычного метода System. exit является приемлемой альтернативой, но не позволяет запустить метод stop.

Среда выполнения JavaFX создает поток приложения JavaFX Application Thread для запуска метода start, обработки входных событий и выполнения анимации.

Создание объектов Scene и Stage, а также модификация графа сцены, должны выполняться в потоке приложения JavaFX Application Thread.

Метод init вызывается в потоке запуска, а не в потоке приложения JavaFX Application Thread.

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

Так как метод init вызывается перед созданием главного потока приложения JavaFX Application Thread, то инициализация JavaFX-приложения в методе init с использованием узлов графа сцены должна осуществляться с применением статического метода Platform.runLater, который позволяет выполнить код в потоке JavaFX Application Thread в какой-то момент времени в будущем.

Метод start класса Application содержит в качестве параметра объект Stage, представляющий графический контейнер главного окна JavaFX-приложения.

Данный объект Stage создается средой выполнения при запуске JavaFX-приложения и передается в метод start главного класса JavaFX-приложения, что позволяет использовать методы объекта Stage для установки и отображения сцены JavaFX-приложения.

Вместо объекта Stage, аргумента метода start, разработчик может создать свой экземпляр класса Stage для отображения сцены JavaFX-приложения.

Перед установкой и отображением сцены в графическом контейнере Stage главного окна JavaFX-приложения необходимо создать граф сцены, состоящий из корневого узла и его дочерних элементов, и на его основе создать объект Scene сцены.

Как правило, в качестве корневого узла используется объект Group или компоновки пакета scene.layout, которые создаются с помощью конструктора и используются в качестве аргумента конструктора при создании объекта Scene.

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

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

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

Создания на основе корневого узла объекта Scene, главное окно Stage устанавливает сцену методом setScene.

Для главного окна устанавливается заголовок методом setTitle.

И окно приложения отображается методом show.

В результате будет сгенерирована основа JavaFX приложения.

Для сборки готового приложения, с помощью выбора команды меню Очистить и построить среды NetBeans в каталоге проекта создается папка dist, содержащая исполняемый JAR-файл JavaFX-приложения, а также JNLP-файл и HTML-страничку для JWS-развертывания приложения.

Также вы можете собрать настольное автономное приложение с EXE-файлом и JavaFX средой выполнения.

Для этого вам нужно предварительно скачать и установить Inno Setup – бесплатный установщик для программ Windows.

Затем вам нужно добавить каталог инструмента Inno Setup в переменную Path переменных системы.

В свойствах проекта нужно отметить флажок Разрешить создание родных пакетов.

После этого при нажатии правой кнопкой мыши на проекте появится меню Пакет как.

Выбрав Установщик EXE, вы получите в каталоге dist папку bundles с EXE установщиком приложения, который установит на компьютер настольное автономное приложение с EXE-файлом и JavaFX средой выполнения.

Также можно сгенерировать MSI установщик вместо EXE установщика.

Для этого нужно скачать и установить инструмент WiX и также добавить его в системную переменную Path.

Для создания автономного приложения В IntelliJ IDEA в свойствах проекта нужно добавить артефакты JavaFX приложения.

И во вкладке JavaFX указать класс приложения, название и другие свойства, а также указать нативный пакет.

После чего в меню Build выбрать Build Artifacts.

В результате в папке проекта out\artifacts будет создана папка bundles с установщиком.

Надпись кнопки также можно установить методом setText.

Методом setOnAction к кнопке присоединяется слушатель нажатия кнопки.

Значок также можно установить для кнопки методом setGraphic.

Методы setLayout узла определяют координаты перемещения узла для его компоновки.

Метод setPrefSize устанавливает предпочтительные размеры компонента в компоновке.

Метод setStyle устанавливает строковое представление стиля CSS, связанного с этим конкретным узлом.

Платформа JavaFX тесно интегрирована с каскадными таблицами стилей CSS, обеспечивающими для узлов графа сцены их внешний вид.

И об этом мы поговорим позже.

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

Метод setBlendMode узла определяет режим наложения этого узла на сцену позади него.

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

Этот метод работает немного по-другому для узла группы Group.

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

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

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

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

Метод setCursor определяет форму курсора мыши для этого узла и его подузлов.

Метод setEffect определяет визуальные эффекты для узла.

Об эффектах мы поговорим позже.

В данном случае к кнопке применяется эффект тени.

Метод setManaged определяет, будет ли компоновка этого узла управляться его родителем.

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

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

Сделать это можно методом resize.

Элементы контроля наследуют от класса Region, который определяет такие свойства, как ширина и высота узла, которые устанавливаются родительским узлом во время компоновки.

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

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

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

Граф сцены обнаруживает динамические изменения узлов, которые влияют на макет (например, изменение размера или содержимого), и вызывает метод requestLayout, который отмечает эту ветку графа как требующую перекомпоновки.

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

Граф сцены поддерживает как изменяемые, так и не изменяемые по размеру узлы.

Метод isResizable узла возвращает, является ли данный узел изменяемым по размеру или нет.

Элементы управления и компоновки изменяются по размеру, но формы, текстовые объекты и группы не изменяются по размеру

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

Поэтому все узлы, которые расширяют Region или Control и устанавливаются как корневой узел, автоматически будут подгоняться под размеры сцены.

Все узлы, которые расширяют группу, не будут подгоняться под размеры сцены.

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

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

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

Та же панель компоновки StackPane не обращает внимание на минимальные размеры, а панель компоновки HBox соблюдает их.

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

Теперь, узел имеет свойство layoutBounds или границы – это прямоугольные границы, которые используются для вычислений компоновки для этого узла.

Компоновочные границы layoutBounds определяются в локальной системе координат узла и могут отличаться от визуальных границ узла и вычисляются по-разному в зависимости от типа узла.

Если тип узла имеет изменяемые размеры, тогда границы layoutBounds всегда совпадают с фактической шириной и высотой узла.

Если узла имеет не изменяемые размеры, тогда границы layoutBounds вычисляются на основе геометрических свойств узла.

Компоновочные границы layoutBounds соответствуют геометрическим границам компонента без учета эффектов, масок, трансформаций, но с учетом установленных размеров.

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

И наконец, узел имеет свойство boundsInParent – это границы узла относительно родительского узла, которые определяются в системе координат родительского узла и учитывают эффекты, маски и трансформации.

Метод setFocusTraversable со значением true определяет, что фокус можно перемещать с помощью стрелок клавиатуры и клавиши Tab.

Надо заметить, что при наведении фокуса на кнопку свойство focused принимает значение true.

При нажатии кнопки с помощью клавиши Enter клавиатуры свойство hover остается со значением false, а при нажатии кнопки мышкой свойство hover принимает значение true.

При нажатии кнопки с помощью мышки значение свойства pressed остается false, а значение свойства armed становится true, так как кнопка активируется не нажатием мышки, а нажатием и освобождением мышки.

При установке свойства mouseTransparent со значением true кнопка активируется только с помощью клавиатуры.

Метод setOpacity устанавливает прозрачность узла.

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

Методы setRotate, setLayout, setScale, setTranslate определяют трансформации узла.

И о трансформациях мы тоже поговорим позже.

Метод setTooltip добавляет всплывающую подсказку к элементу контроля.

Метод setAlignment указывает, как текст и графика в кнопке должны быть выровнены, когда есть пустое пространство.

Метод setContentDisplay определяет расположение графического объекта относительно текста в кнопке.

Метод setUnderline подчеркивает текст кнопки.

Метод setWrapText переносит непомещающийся текст на другую строку.

Если установить свойство cancelButton со значением true, тогда кнопка будет активироваться клавишей Esc, а не клавишей Enter.

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

Однако данный порядок можно менять с помощью методов toBack () и toFront ().

Все компоненты управления происходят от класса Control, который, в свою очередь, является областью Region, которая является узлом Node.

Класс Control реализует интерфейс Skinnable, который имеет методы getSkin и setSkin.

Таким образом, каждый элемент управления имеет ссылку на единственный объект Skin, который представляет собой реализацию представления View архитектуры MVC для элемента управления.

Кроме того, имеются CSS стили для определения свойств визуального представления элемента управления, так как класс Control реализует интерфейс Styleable и имеет метод getUserAgentStylesheet, который возвращает CSS стили элемента.

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

Также, скин работает как менеджер компоновки для своих дочерних элементов.

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

Объект Skin реализует поведение элемента управления с помощью класса BehaviorBase.

Объект Skin элемента управления может быть изменен в любое время.

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

Элементы управления соответствуют классическому шаблону проектирования MVC.

Класс Control – это «модель».

Он содержит как состояние компонента, так и методы, которые манипулируют этим состоянием.

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

Эти задачи делегируются объекту Skin («view»).

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

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

На самом деле элемент управления будет иметь нулевую ширину и высоту.

В какой-то момент после создания нового экземпляра элемента управления, разработчик, скорее всего, разместит элемент управления в графе сцены, вызвав метод getChildren. аdd где-то в своем коде.

В этот момент элемент управления станет частью графа сцены, который перерисовывается системой, и поэтому, для него будут выполнены css, layout и rendering.

Первым будут выполнены CSS стили.

При этом, если в данный момент явно не установлен скин методом setSkin, проверяется, имеется ли ссылка на пользовательскую таблицу CSS стилей методом getUserAgentStylesheet, и если да, тогда она устанавливается в CSS движок для стилизации элемента управления.

В таблице CSS стилей ищется свойство -fx-skin для загрузки экземпляра скина.

Далее, элемент управления загружает CSS стили родительских классов.

Это также может привести к загрузке экземпляра скина путем чтения свойства -fx-skin из таблицы CSS стилей.

Если же при этом скин по-прежнему равен нулю, элемент управления вызывает метод createDefaultSkin создания скина по умолчанию.

И этот возвращенный методом экземпляр Skin будет использоваться как скин для элемента управления.

Если же метод createDefaultSkin возвращает нуль, тогда визуальное представление элемента управления будет полностью определяться CSS стилями.

Теперь рассмотрим использование Skin на примере создания пользовательского элемента управления.

В конструкторе этого класса устанавливается пользовательский скин либо с помощью CSS свойства -fx-skin, либо методом setSkin, либо в этом классе переопределяется метод createDefaultSkin.

Пользовательский скин расширяет класс SkinBase и в пользовательском скине используется объект BehaviorBase, отвечающий за реализацию взаимодействия с пользователем.

В конструкторе скина с помощью метода getChildren.addAll можно добавить дочерние узлы в скин.

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

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

Вместо класса Control можно расширить существующий элемент управления, расширяя его класс скина.

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

Использование CSS-стилей платформой JavaFX основывается на спецификации CSS версии 2.1 с некоторыми дополнениями спецификации CSS 3.0 и расширениями, специфичными для JavaFX-технологии.

По умолчанию внешний вид компонентов платформы JavaFX определяется CSS-стилями файла modena. css библиотеки jfxrt. jar.

Стили сначала применяются к родителям, а затем к их детям.

При этом, к узлу применяются CSS стили только после его добавления в граф сцены.

Стили CSS применяются до того, как граф сцены будет скомпонован и нарисован.

Применять CSS-стили для изменения внешнего вида по умолчанию узлов графа сцены можно двумя способами.

Первый способ – это создание отдельных файлов CSS-стилей с расширением. css и размещение их в каталоге главного класса JavaFX-приложения.

В этом случае загрузить созданные CSS-стили в сцену JavaFX-приложения позволяет метод getStylesheets().addAll класса Scene, где указывается URL-адрес CSS-файла.

Или можно использовать метод setUserAgentStylesheet, где также указывается URL-адрес CSS-файла.

И URL-адрес CSS-файла может быть получен с помощью метода:

this.getClass().getResource("stylesheet.css").toString ()

Файл CSS-стилей содержит набор CSS-правил.

При этом каждое CSS-правило состоит из набора CSS-селекторов и объявлений CSS-свойств, применяемых к указанному набору.

Для платформы JavaFX в качестве селекторов могут применяться:

Имена узлов графа сцены, например,.button или. check-box.

Примеры использования таких селекторов можно посмотреть в CSS файле по умолчанию modena. css библиотеки jfxrt. jar.

В этом случае значения CSS-свойств в фигурных скобках применяются к указанным узлам графа сцены.

С помощью селектора. root определяется CSS-стиль корневого узла графа сцены.

Такой селектор можно связать с конкретным экземпляром JavaFX-компонента с помощью метода getStyleClass().add () класса Node.

В качестве селекторов могут применяться также ID-идентификаторы узлов графа сцены.

В этом случае значения CSS-свойств в фигурных скобках применяются к узлам графа сцены с указанными идентификаторами.

Идентификатор узла устанавливается с помощью метода setId () класса Node.

В качестве селекторов также могут применяться имена вложенных элементов для составных JavaFX-элементов, например,.check-box. text или. check-box. box – значения CSS-свойств будут применены к элементу text или элементу box переключателя check-box.

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

И наконец, в качестве селекторов также применяться псевдоклассы, представляющие состояния узла графа сцены, например,.button: focused или hover или armed.

Эти состояния также можно посмотреть в CSS файле по умолчанию modena. css библиотеки jfxrt. jar.

В этом случае значения CSS-свойств в фигурных скобках применяются к узлу графа сцены в указанном состоянии.

CSS-свойства, указываемые в блоке объявлений CSS-правила платформы JavaFX, имеют префикс -fx- и соответствуют некоторым свойствам CSS-спецификации или ее расширениям.

Другой способ использования CSS-стилей для изменения внешнего вида по умолчанию узла графа сцены – это применение метода setStyle класса Node, содержащего в качестве аргумента строку блока объявлений CSS-правила.

Метку также можно установить методом setText.

А первоначальный выбор переключателя можно установить методом setSelected (true).

С помощью метода setIndeterminate (true) можно установить неопределенное состояние выбора переключателя.

И метод setAllowIndeterminate (true) добавляет это неопределенное состояние к двум другим состояниям выбора переключателя.

Таким образом, у переключателя появляются три состояния.

Отличие набора свойств компонента CheckBox от набора свойств компонента Button заключается в наличии свойств indeterminate, selected и allowIndeterminate.

У компонента CheckBox есть метод selectedProperty, который возвращает свойство состояния выбора переключателя.

И метод indeterminateProperty, который возвращает свойство неопределенного состояния переключателя.

К этим свойствам можно присоединить слушателя изменения свойства.

И о свойствах JavaFX компонентов мы поговорим далее.

Компоненты JavaFX Beans и связывание данных

Платформа Java определяет JavaBeans-компоненты, которые используются для передачи данных.

JavaBeans-компоненты представлены Java-классами, которые созданы по определенным правилам.

Классы JavaBeans-компонентов имеют публичный конструктор без параметров, свойства класса доступны через методы get и set, классы имеют методы add и remove добавления и удаления слушателей событий, и классы обладают свойством сериализуемости (преобразования в последовательность байт и обратно) путем реализации интерфейса java.io.Serializable.

Кроме того, платформа Java содержит программный интерфейс JavaBeans API для создания и обработки JavaBeans-компонентов.

Все Swing и AWT компоненты являются идеальными JavaBeans компонентами.

JavaFX компоненты не являются классическими JavaBeans компонентами, так как они не реализуют интерфейс Serializable.

Сериализация JavaFX компонентов возможно через декларативное FXML описание интерфейса, с которым мы познакомимся позже.

Однако платформа JavaFX расширяет JavaBeans-модель, определяя JavaFX-свойства.

И именно JavaFX-свойства используют JavaFX компоненты.

JavaFX-свойства реализованы пакетами beans, beans.binding, beans.property и beans.value программного интерфейса JavaFX API.

Конечной реализацией JavaFX-свойств являются классы пакета beans.property SimpleХХХProperty для свойств записи и чтения и классы ReadOnlyХХХWrapper для свойств только чтения.

Данные классы реализуют интерфейсы Observable, Property, ReadOnlyProperty, ObservableValue и WritableValue, предоставляя методы:

addListener и removeListener присоединения и удаления слушателей недействительности и изменения значения свойства.

Методы bind, bindBidirectional, unbind и unbindBidirectional связывания и удаления связывания значения свойства.

Методы getBean и getName, возвращающий объект JavaFX Beans-компонента, содержащего свойство, и возвращающий имя свойства;

Методы get и set чтения и записи значения свойства.

Кроме того, данные классы расширяют классы XXXExpression пакета beans.binding, обеспечивающие для JavaFX-свойств методы создания объектов XXXBinding, которые представляют выражения, результат которых синхронизирован со значением данного свойства и со значением объекта, выступающим в качестве аргумента вышеупомянутых методов.

Таким образом, JavaFX Beans-компонент представлен классом, имеющим:

Во-первых, публичный конструктор без параметров.

Во-вторых методы get () и set () доступа к свойствам класса.

И в-третьих методы xxxProperty (), возвращающие JavaFX-свойства.

В качестве примера рассмотрим компонент Button.

Класс Button имеет унаследованные от класса Node свойства, унаследованное от класса Parent свойство, унаследованные от класса Control свойства, унаследованные от класса Labeled свойства, унаследованные от класса ButtonBase свойства, и собственные свойства.

Какие-то из этих свойств доступны для чтения и записи, а какие-то – только для чтения.

Для каждого свойства чтения и записи класс Button предоставляет методы доступа get и set, а для свойства только чтения – только метод get, а также метод xxxProperty, возвращающий само JavaFX-свойство ХХХProperty или ReadOnlyХХХProperty.

Рассмотрим свойство text класса Button.

Метод textProperty кнопки Button возвращает JavaFX-свойство StringProperty, определяющее значение свойства text.

Установить значение данного JavaFX-свойства и соответственно значение свойства text кнопки Button можно методом set интерфейса WritableObjectValue или методом setValue класса StringProperty.

Возвращает значение свойства text кнопки Button метод get интерфейса ObservableObjectValue или метод getValue класса StringExpression.

При этом методы getBean и getName вернут класс Button и имя свойства text.

Применяя метод bind интерфейса Property к JavaFX-свойству текста кнопки Button можно связать его значение, например, со значением JavaFX-свойства текста поля TextField так, что, набирая текст в поле TextField, он будет автоматически становиться текстом кнопки Button.

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

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

Связывание просматривает список зависимостей для изменений, а затем автоматически обновляется после обнаружения каких-либо изменений.

Применяя метод bindBidirectional класса StringProperty к JavaFX-свойству текста кнопки Button можно связать его значение, например, со значением JavaFX-свойства текста поля TextField так, что в нем будет автоматически отображаться измененный текст кнопки Button.

Организовать прослушивание изменения значения JavaFX-свойства текста кнопки Button позволяет метод addListener интерфейса ObservableValue.

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

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

Метод addListener (InvalidationListener listener) интерфейса Observable позволяет организовать прослушивание недействительности значения JavaFX-свойства текста кнопки Button.

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

Так как JavaFX-свойство StringProperty текста кнопки Button расширяет класс StringExpression, его методы позволяют организовать различного рода связанные вычисления.

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

В JavaFX приложениях также можно использовать самостоятельные JavaFX-свойства, безотносительно к JavaFX-компонентам.

Для этого необходимо создавать экземпляры классов SimpleХХХProperty пакета beans.property.

Так как данные классы расширяют классы XXXExpression пакета beans.binding, при этом можно создавать связанные вычисления.

Для создания связанных вычислений платформа JavaFX предлагает два типа программного интерфейса – High-Level Binding API и Low-Level Binding API.

Программный интерфейс High-Level Binding API также подразделяется на Fluent API и на применение класса Bindings.

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

Здесь приведен пример использования Fluent API.

В этом примере, в поле TextField отобразится сумма значений двух JavaFX-свойств SimpleDoubleProperty.

Здесь приведен пример использования класса Bindings для создания связанных вычислений.

В этом примере, в поле TextField также отобразится сумма значений двух JavaFX-свойств SimpleDoubleProperty.

Здесь приведен пример использования Low-Level Binding API для создания связанных вычислений.

Для применения Low-Level Binding API необходимо расширять классы ХХХBinding пакета beans.binding с переопределением их метода computeValue.

Здесь вызов метода bind в конструкторе класса запускает наблюдение за изменениями зависимостей.

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

И все события платформы JavaFX представлены подклассами базового класса Event.

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

JavaFX-события характеризуются источником события, целью события и типом события.

Как правило, источником события и целью события служит один и тот же JavaFX-компонент. Однако статический метод fireEvent класса Event позволяет послать событие определенной цели события.

В этом примере, при нажатии кнопки btn1 срабатывает обработчик событий кнопки btn2.

Так как в обработчике кнопки btn1 мы посылаем событие методом fireEvent другой кнопке.

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

За создание цепочки доставки события JavaFX-компонента отвечает метод buildEventDispatchChain класса Node, возвращающий объект EventDispatchChain.

Методы append и prepend интерфейса EventDispatchChain позволяют добавить объект EventDispatcher в конец и в начало исходной цепочки доставки события, а метод dispatchEvent интерфейса EventDispatchChain обеспечивает доставку определенного события JavaFX-компоненту.

Объект EventDispatcher является реализацией интерфейса EventDispatcher, который имеет единственный метод dispatchEvent, отвечающий за дальнейшую передачу события через цепочку доставки с возможностью его обработки, модификации, замены или отклонения, где event – это передаваемое событие, а tail – остаток цепочки доставки.

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

С помощью метода setEventDispatcher класса Node можно определить пользовательский EventDispatcher-объект для JavaFX-компонента.

В этом примере, при нажатии кнопки btn1 также срабатывает обработчик событий кнопки btn2.

Каждый объект EventDispatcher в цепочке EventDispatchChain отвечает за пересылку события в остальную часть цепочки во время диспетчеризации событий.

В пользовательском объекте EventDispatcher для кнопки btn1 мы отправляем событие другой кнопке.

Процесс доставки события через цепочку доставки EventDispatchChain разделяется на две фазы.

Первая фаза называется фазой захвата (capturing phase) и состоит из передачи события от корневого узла к узлу цели события, от первого элемента цепочки EventDispatchChain, связанной с целью события, до ее последнего элемента.

Вторая фаза – восходящая фаза (bubbling phase) заключается в противоположном движении события от узла цели события к корневому узлу цепочки доставки.

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

После того, как узел графа сцены выбран как цель события, маршрут события или цепочка доставки события EventDispatchChain устанавливается реализацией по умолчанию метода buildEventDispatchChain интерфейса EventTarget в классе Node.

На этапе захвата события событие отправляется корневым узлом приложения по цепочке доставки события целевому узлу.

На этом этапе происходит обработка события фильтрами события.

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

Когда фильтр завершает свою работу, событие передается следующему узлу по цепочке.

Фильтр регистрируется методом addEventFilter класса Node.

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

На этом этапе происходит обработка события обработчиками события.

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

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

Обработчик регистрируется методом addEventHandler класса Node.

Тип события, представленный классом EventType, определяет характеристику события.

Или другими словами, типы события дополнительно классифицируют события одного класса событий, например, KEY_PRESSED, KEY_RELEASED или KEY_TYPED.

При этом типы событий образуют иерархическую структуру с корневым типом ANY.

Имя типа события для Event-объекта можно получить методом getEventType.getName.

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

Это могут быть или фильтры, или обработчики событий.

Объект EventHandler создается с помощью реализации интерфейса EventHandler, переопределяя его метод handle, в котором и обрабатывается событие.

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

Для этого в методе handle нужно вызвать метод consume для объекта события.

Отличие набора свойств компонента Hyperlink от набора свойств компонента Button заключается в наличии свойства visited, которое принимает значение true при активации гиперссылки.

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

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

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

Для того чтобы убрать рамку, можно использовать CSS свойство -fx-border-width.

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

Чтобы изменить внешний вид гиперссылки при наведении курсора мыши и нажатии, можно использовать обработчики событий OnMouseEntered, OnMousePressed и OnMouseExited.

Сама функциональность гиперссылки определяется в обработчике события действия OnAction.

Здесь можно запустить браузер WebView или же можно полностью обновить сцену.

Компонент Label обеспечивает отображение текстовой подписи, изображения, текстовой подписи и изображения.

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

Цвет текста можно установить методом setTextFill.

Шрифт можно установить методом setFont.

И перенос текста на новую строку можно установить методом setWrapText (true).

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

Кнопка ToggleButton может быть создана с помощью конструктора, в котором можно указать надпись кнопки и ее изображение.

Отличие набора свойств компонента ToggleButton от набора свойств компонента Button заключается в наличии свойств selected и toggleGroup.

Свойство selected принимает значение true, если кнопка ToggleButton находится в нажатом состоянии, и значение false – если кнопка ToggleButton отжата.

Свойство toggleGroup указывает группу ToggleGroup, к которой принадлежит кнопка ToggleButton.

Объединение кнопок ToggleButton в группу ToggleGroup отличается от объединения кнопок RadioButton в группу ToggleGroup – в группе кнопок RadioButton по меньшей мере одна кнопка должна находиться в выбранном состоянии.

В группе кнопок ToggleButton такой функциональности нет.

Объединение кнопок ToggleButton в группу обеспечивает эффект нажатия только единственной кнопки в группе.

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

Кнопка добавляется в группу с помощью метода setToggleGroup.

Группа ToggleGroup имеет свойство selectToggle – выбранная кнопка.

К этому свойству можно присоединить слушателя, в который будет передана выбранная кнопка, представленная объектом Toggle.

Toggle – это интерфейс, который реализуется кнопкой ToggleButton.

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

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

Кнопка RadioButton – это специализированный тип кнопки ToggleButton.

Кнопка RadioButton может быть выбрана или не выбрана.

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

Свойства компонента RadioButton аналогичны свойствам компонента ToggleButton.

Объединение кнопок RadioButton в группу ToggleGroup отличается от объединения кнопок ToggleButton в группу ToggleGroup.

В группе кнопок RadioButton по меньшей мере одна кнопка должна находиться в выбранном состоянии и выбор другой кнопки отменяет выбор всех остальных кнопок.

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

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

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

Изображение для переключателя можно установить отдельно методом setGraphic.

Переключатель добавляется в группу методом setToggleGroup.

Обработать выбор переключателя можно с помощью слушателя свойства selectedToggle группы или с помощью слушателя свойства selected переключателя.

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

Набор элементов ObservableList списка ChoiceBox может быть создан с помощью статического метода observableArrayList класса FXCollections пакета javafx.collections.

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

За выбор элементов списка отвечает модель SelectionModel, которая имеет свойства selectedIndex и selectedItem.

К этим свойствам можно присоединить слушателя и обрабатывать выбор пользователя.

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

JavaFX Collections является расширением фреймворка Java Collections Framework, включающего в себя список java.util.List, карту java.util.Map и набор java.util.Set.

JavaFX Collections содержит список ObservableList, карту ObservableMap и набор ObservableSet.

JavaFX Collections расширяет фреймворк Java Collections Framework возможностью регистрировать слушателей изменений коллекции, так как ObservableList, ObservableMap и ObservableSet дополнительно расширяют интерфейс Observable.

К обычной коллекции фреймворка Java Collections Framework нельзя присоединить слушателя изменений.

С помощью класса FXCollections можно обернуть обычную коллекцию в JavaFX коллекцию и присоединить к ней слушателя изменений.

Также класс FXCollections позволяет сортировать, копировать и соединять коллекции.

Свойство onAction позволяет определить для поля TextField обработчик нажатия клавиши Enter, а свойство promptText дает возможность установить фоновый текст подсказки для ввода пользователю.

Подсказка устанавливается методом setPromptText.

При этом, чтобы подсказка отобразилась, нужно убрать фокус с поля, так как подсказка исчезает при получении полем фокуса.

Фокус убирается методом setFocusTraversable (false).

Обработчик нажатия клавиши Enter устанавливается методом setOnAction.

И в нем извлечь введенный пользователем текст можно методом getText.

Также для поля TextField есть многочисленные методы редактирования текста, вставки, копирования, вырезания, выделения и так далее.

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

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

Изменить маску символов, можно расширив скин TextFieldSkin и переопределив его метод maskText.

Затем устанавливаем новый скин методом setSkin для компонента PasswordField.

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

Компонент TextArea создается с помощью конструктора, в котором можно сразу указать отображаемый текст.

Или это можно сделать с помощью метода setText.

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

Или же можно определить ширину компонента и количество отображаемых строк с помощью метода setPrefRowCount.

Или же можно определить высоту компонента и количество отображаемых столбцов с помощью метода setPrefColumnCount.

Текст можно сделать редактируемым с помощью метода setEditable (true).

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

Методом setWrapText (true) устанавливается перенос строк текста.

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

Компонент ScrollPane имеет набор свойств, таких как content, fitToHeight, fitToWidth, hbarPolicy, vbarPolicy, и так далее.

С помощью свойства content устанавливается узел Node, отображаемый панелью ScrollPane.

Свойства hmax, hmin, hvalue, vmax, vmin, vvalue определяют позиции горизонтальной и вертикальной прокруток.

С помощью свойств hbarPolicy и vbarPolicy устанавливается отображение горизонтальной и вертикальной прокруток.

Если отображаемый панелью узел Node может изменять свои размеры (isResizable), тогда в случае значения true свойств fitToHeight и fitToWidth размеры узла Node подгоняются к размерам панели ScrollPane.

Если свойство pannable принимает значение true, тогда пользователь может колесом мышки прокручивать панель по вертикали.

С помощью свойств prefViewportHeight и prefViewportWidth можно устанавливать предпочтительные размеры окна панели ScrollPane, однако данные свойства имеют меньший приоритет по отношению к свойствам prefHeight и prefWidth.

Узел устанавливается в панель методом setContent.

Появление полос прокрутки панели определяется методами setHbarPolicy и setVbarPolicy.

В которых используются константы ALWAYS, AS_NEEDED и NEVER.

Если размеры узла больше, чем размеры панели и размеры узла изменяемые, тогда при вызове метода setFitToWidth (true) ширина узла примет ширину панели, а при вызове метода setFitToHeight (true), высота узла примет высоту панели.

При вызове метода setPannable (true), контент панели можно прокручивать колесом мыши.

Если для панели вызван метод setPrefSize, тогда методы setPrefViewportHeight и setPrefViewportWidth не окажут никакого влияния на размер панели.

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

Или же этот список элементов компонента можно задать позже с помощью метода setItems.

Список ObservableList создается с помощью вспомогательного класса FXCollections.

Размеры списка устанавливаются методом setPrefSize.

С помощью свойства orientation класса ListView можно установить будет ли список вертикальным или горизонтальным списком элементов.

Методом setOrientation можно изменить ориентацию списка с вертикальной на горизонтальную.

Свойство cellFactory класса ListView позволяет заполнить список ListView пользовательскими компонентами ListCell.

Класс ListCell представляет отображаемый элемент списка ListView.

Изменить свойство cellFactory можно методом setCellFactory, в который можно передать ListCell реализацию CheckBoxListCell, ChoiceBoxListCell, ComboBoxListCell, или TextFieldListCell.

Или же можно создать свой компонент ListCell и вернуть его в переопределенном методе call интерфейса, который служит аргументом метода setCellFactory.

Свойство selectionModel класса ListView дает возможность определить множественность выбора и обработку события выбора элемента списка.

Множественность выбора элементов списка устанавливается методом setSelectionMode.

Обработка выбора элемента списка пользователем обрабатывается с помощью присоединения слушателя свойства selectedItemProperty модели выбора SelectionModel.

Чтобы сделать список редактируемым, во-первых, нужно вызвать метод setEditable (true) для списка.

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

Каждое JavaFX свойство модели данных предназначено представлять столбец таблицы.

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

После создания модели данных, мы создаем список ObservableList данных для строк таблицы, то есть список экземпляров класса модели данных, используя класс FXCollections.

Далее мы создаем столбцы таблицы.

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

С помощью свойства cellValueFactory класса TableColumn, ячейки столбца таблицы заполняются данными.

То есть свойство cellValueFactory связывает конкретный столбец TableColumn с конкретным полем класса модели данных.

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

Под капотом, это работает как определение метода call интерфейса Callback, в котором возвращается соответствующее поле класса модели данных.

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

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

После создания столбцов, создается таблица TableView с помощью конструктора, в котором можно сразу указать список ObservableList данных для строк таблицы.

Или же его можно установить позже методом setItems.

Столбцы добавляются в таблицу методом getColumns.addAll.

Если уже после создания таблицы к списку ObservableList данных для строк таблицы добавить новый элемент, таблица TableView автоматически обновится и отобразит новую строку.

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

Это свойство определяется методом setTableMenuButtonVisible (true).

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

С помощью CSS свойства -fx-font можно установить шрифт для таблицы.

Размеры таблицы устанавливаются методом setPrefSize.

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

Если ширина и высота таблицы избыточны, в таблице отображаются пустые строки и столбцы.

Методом setCursor можно установить курсор для таблицы, а методом setTooltip можно установить всплывающую подсказку для таблицы.

Столбец TableColumn может содержать набор ObservableList вложенных столбцов, заполнить который можно с помощью метода getColumns.addAll класса TableColumn.

Свойство placeholder дает возможность установить узел Node, отображаемый в случае отсутствия данных таблицы.

Для этого используется метод setPlaceholder таблицы.

Свойство selectionModel дает возможность определить выделенные элементы таблицы и установить множественность выбора.

Возможность выбора нескольких строк устанавливается методом setSelectionMode с константой MULTIPLE для модели выбора SelectionModel.

Также для свойств selectedIndexProperty и selectedItemProperty модели выбора можно установить слушателя, который будет обрабатывать выбор строк таблицы пользователем.

По умолчанию, данные в столбцах можно сортировать.

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

Первый щелчок сортирует данные столбца по возрастанию, второй щелчок сортирует данные столбца по убыванию, а третий клик отключает сортировку.

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

Чтобы отсортировать несколько столбцов, пользователь нажимает клавишу Shift, щелкая по заголовку каждого столбца для сортировки.

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

При этом можно установить порядок сортировки для каждого столбца списка.

Чтобы запретить сортировку данных, нужно вызвать метод setSortable (false) для столбца.

Свойство editable классов TableColumn и TableView определяет редактируемость столбца и таблицы.

По умолчанию это свойство имеет значение false.

Свойство cellFactory класса TableColumn дает возможность наполнить столбец пользовательскими компонентами, представленными классом TableCell, с помощью метода setCellFactory.

У класса TableCell есть стандартные реализации CheckBoxTableCell, ChoiceBoxTableCell, ComboBoxTableCell, ProgressBarTableCell, TextFieldTableCell.

В этом примере мы передаем в метод setCellFactory ячейку с текстовым полем TextFieldTableCell.

Свойства onEditCancel, onEditCommit и onEditStart обеспечат обработку событий редактирования.

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

Для создания столбца со своими, пользовательскими редактируемыми элементами, необходимо создать класс, расширяющий класс TableCell, в котором переопределяются методы startEdit, cancelEdit, commitEdit и updateItem с использованием редактируемых текстовых полей, и наполнить его экземплярами столбец с помощью свойства cellFactory.

Дерево TreeView создается на основе корневого узла, который определяется свойством root и представлен классом TreeItem.

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

А затем создаем дерево TreeView с помощью конструктора, в котором можем сразу указать корневой узел, или установить корневой узел для дерева с помощью метода setRoot.

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

Метод getChildren.addAll класса TreeItem позволяет добавить в узел TreeItem набор дочерних узлов.

Если узел не содержит дочерних элементов, он называется листом.

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

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

Размеры дерева устанавливаются методом setPrefSize.

И рамку дерева можно стилизовать с помощью CSS свойства -fx-border.

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

Однако в дереве отображается строковое представление этого объекта, полученное методом toString.

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

Свойство selectionModel класса TreeView дает возможность определить множественность выбора и обработку события выбора узла дерева.

Возможность выбора нескольких узлов устанавливается методом setSelectionMode с константой MULTIPLE для модели выбора SelectionModel.

Также для свойств selectedIndexProperty и selectedItemProperty модели выбора можно установить слушателя, который будет обрабатывать выбор узлов дерева пользователем.

Свойство cellFactory класса TreeView позволяет заполнить дерево TreeView пользовательскими компонентами TreeCell.

Компонент TreeCell отвечает за отображение узла дерева TreeView.

Класс TreeCell имеет стандартные реализации CheckBoxTreeCell, ChoiceBoxTreeCell, ComboBoxTreeCell, TextFieldTreeCell.

Свойство editable класса TreeView определяет редактируемость дерева.

По умолчанию это свойство имеет значение false.

В этом примере мы создаем редактируемое дерево, передавая в метод setCellFactory ячейку с текстовым полем TextFieldTreeCell.

Свойства onEditCancel, onEditCommit и onEditStart дерева обеспечивают обработку событий редактирования.

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

Для создания дерева со своими, пользовательскими редактируемыми ячейками, необходимо создать класс, расширяющий класс TableCell, в котором переопределяются методы startEdit, cancelEdit, commitEdit и updateItem с использованием редактируемых текстовых полей, и наполнить его экземплярами дерево с помощью свойства cellFactory.

Компонент TreeTableView имеет много общего с элементами управления TreeView и TableView, он объединяет и расширяет некоторые аспекты их функциональности.

Для создания компонента TreeTableView, сначала, как и для таблицы, создается модель данных.

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

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

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

С помощью свойства cellValueFactory класса TreeTableColumn, ячейки столбца таблицы заполняются данными.

При этом свойство cellValueFactory связывает конкретный столбец TreeTableColumnс конкретным полем класса модели данных.

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

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

Или же его можно установить позже методом setRoot.

Столбцы добавляются в компонент TreeTableView методом getColumns.setAll.

Как и для таблицы, с помощью метода setTableMenuButtonVisible (true) можно установить контекстное меню, позволяющее регулировать отображение столбцов таблицы.

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

С помощью CSS свойства -fx-font можно установить шрифт для компонента TreeTableView.

Размеры компонента TreeTableView устанавливаются методом setPrefSize.

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

Если ширина и высота избыточны, в таблице отображаются пустые строки и столбцы.

Методом setCursor можно установить курсор для компонента, а методом setTooltip можно установить всплывающую подсказку для компонента.

Столбец TreeTableColumn может содержать набор ObservableList вложенных столбцов, заполнить который можно с помощью метода getColumns.addAll класса TreeTableColumn.

Метод setPlaceholder дает возможность установить узел Node, отображаемый в случае отсутствия данных.

Эта ситуация возникает, если не определить корневой узел для компонента TreeTableView.

Возможность выбора нескольких строк устанавливается методом setSelectionMode с константой MULTIPLE для модели выбора SelectionModel.

Для свойств selectedIndexProperty и selectedItemProperty модели выбора можно установить слушателя, который будет обрабатывать выбор строк таблицы пользователем.

Как и для таблицы, для компонента TreeTableView, данные в столбцах можно сортировать.

Чтобы запретить сортировку данных, нужно вызвать метод setSortable (false) для столбца.

Свойство editable классов TreeTableColumn и TreeTableView определяет редактируемость столбца и таблицы.

По умолчанию это свойство имеет значение false.

Свойство cellFactory класса TreeTableColumn дает возможность наполнить столбец пользовательскими компонентами, представленными классом TreeTableCell, с помощью метода setCellFactory.

У класса TreeTableCell есть стандартные реализации CheckBoxTreeTableCell, ChoiceBoxTreeTableCell, ComboBoxTreeTableCell, ProgressBarTreeTableCell, и TextFieldTreeTableCell.

В этом примере мы передаем в метод setCellFactory ячейку с текстовым полем TextFieldTreeTableCell.

Свойства onEditCancel, onEditCommit и onEditStart обеспечивают обработку событий редактирования.

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

Для создания столбца со своими, пользовательскими редактируемыми элементами, необходимо создать класс, расширяющий класс TreeTableCell, в котором переопределяются методы startEdit, cancelEdit, commitEdit и updateItem с использованием редактируемых текстовых полей, и наполнить его экземплярами столбец с помощью свойства cellFactory.

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

Это регулируется свойством visibleRowCount.

Этим ComboBox отличается от компонента ChoiceBox.

Кроме того, у компонента ComboBox есть такие свойства как cellFactory, placeholder, editable, и promptText.

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

Набор элементов ObservableList списка ComboBox может быть создан с помощью класса FXCollections.

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

За выбор элементов списка отвечает модель SelectionModel, которая имеет свойства selectedIndex и selectedItem.

К этим свойствам можно присоединить слушателя и обрабатывать выбор пользователя.

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

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

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

Методом setVisibleRowCount ограничивается количество отображаемых элементов в выпадающем списке.

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

Методом setEditable (true) можно сделать поле ComboBox редактируемым.

Метод setPromptText позволяет установить подсказку в редактируемое поле.

Правда при этом нужно убрать с поля фокус.

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

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

Свойство cellFactory класса ComboBox позволяет заполнить выпадающий список пользовательскими компонентами ListCell.

Класс ListCell представляет отображаемый элемент списка ComboBox.

Изменить свойство cellFactory можно методом setCellFactory, в который можно передать стандартную реализацию ListCell – это CheckBoxListCell, ChoiceBoxListCell, ComboBoxListCell, или TextFieldListCell.

Или же можно создать свой компонент ListCell и вернуть его в переопределенном методе call интерфейса, который служит аргументом метода setCellFactory.

Свойство orientation компонента определяет – будет ли разделитель горизонтальным или вертикальным.

Так как сам по себе разделитель Separator представлен линией, а разделитель имеет определенную ширину и высоту, то свойства halignment и valignment определяют выравнивание линии для вертикального и горизонтального разделителя соответственно.

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

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

Свойства компонента max, min и value определяют диапазон и текущее значение ползунка.

Свойство blockIncrement определяет перемещение ползунка при управлении клавишами клавиатуры.

Свойство majorTickUnit определяет расстояние между главными метками ползунка.

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

К свойству value можно присоединить слушателя и обрабатывать перемещение ползунка.

Свойство компонента progress, представляющее процент выполнения задачи, своим значением от 0.0 до 1.0 определяет заполнение и текст индикатора ProgressIndicator.

Свойство компонент indeterminate принимает значение true, если свойство progress установлено со значением -1 – это означает, что индикатор показывает выполнение процесса, не имеющего определенного интервала.

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

В этом примере мы создаем индикаторы ProgressIndicator и ProgressBar.

И мы создаем JavaFX свойство DoubleProperty, которое связываем со свойствами progress индикаторов.

Изменяя одно это свойство, мы автоматически изменяем свойства progress этих двух индикаторов.

Если мы установим значение этого свойства -1, индикаторы станут показывать неопределенный прогресс.

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

Окно подсказки Tooltip присоединяется к компоненту управления Control с помощью установки его свойства tooltip или к узлу Node с помощью статического метода install класса Tooltip.

Так как класс Tooltip является расширением класса Labeled, вы можете добавить не только текст, но и изображение в окно подсказки.

Метод setHtmlText класса HTMLEditor позволяет установить первоначальную HTML-разметку редактора.

На основе первоначальной HTML-разметки, включенных опций редактора и введенного текста редактор HTMLEditor формирует HTML-разметку, получить доступ к которой можно с помощью метода getHtmlText класса HTMLEditor.

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

Теперь, вводимый в редакторе HTMLEditor контент будет вставляться в этот контейнер.

Вверху окна у нас компонент WebView, который отображает HTML-контент.

А в нижней части окна у нас редактор HTMLEditor, в котором мы можем устанавливать различные опции для формирования HTML разметки.

При нажатии кнопки, компонент WebView отображает созданную HTML разметку, а компонент Label отображает исходный HTML код.

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

С помощью свойства компонента content устанавливается узел Node, отображаемый в панели TitledPane.

Свойство graphic позволяет установить узел Node, представляющий заголовок панели.

Свойство expanded принимает значение true, если панель раскрыта и отображает свое содержимое.

Если значение свойства collapsible установлено false, тогда панель TitledPane не имеет опции сворачивания.

Установка true значения свойства animated делает сворачивание и разворачивание панели TitledPane плавным.

Панель TitledPane автоматически принимает ширину узла Node заголовка панели или ширину узла Node содержимого панели – что окажется больше.

Высота панели TitledPane автоматически становится равной высоте узла Node содержимого панели.

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

Затем мы создаем компонент заголовка и добавляем его в панель методом setGraphic.

Далее мы создаем компонент контента и добавляем его в панель методом setContent.

Панель Accordion состоит из набора ObservableList горизонтальных панелей с заголовком, пополнить который можно с помощью метода getPanes.addAll класса Accordion.

Свойство компонента expandedPane определяет первоначально раскрытую панель TitledPane.

В этом примере мы создаем набор панелей TitledPane и добавляем их в Accordion.

Методом setExpandedPane мы устанавливаем первую панель раскрытой.

Компонент MenuBar содержит список ObservableList компонентов меню Menu, который можно пополнить с помощью метода getMenus.addAll класса MenuBar.

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

Компоненты меню Menu панели MenuBar также содержат свои наборы ObservableList компонентов MenuItem, которые можно заполнить с помощью метода getItems.addAll класса Menu.

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

Класс MenuItem расширяется классами CheckMenuItem, CustomMenuItem, Menu, и RadioMenuItem.

Поэтому в компонент меню Menu панели MenuBar можно добавлять не только элементы MenuItem, но и переключатели CheckMenuItem и RadioMenuItem, а также разделители SeparatorMenuItem, представленные классом SeparatorMenuItem, расширяющим класс CustomMenuItem, и вложенные меню Menu.

В этом примере мы создаем панель меню, стилизуем ее и устанавливаем размеры.

Затем мы создаем меню File, для которого создаем элемент Print.

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

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

И создаем простой элемент флажка, который отделяем элементом разделителя.

Все эти элементы мы добавляем в меню методом getItems.addAll.

А само меню добавляем в панель меню методом getMenus.addAll.

Элементы контекстного меню ContextMenu представлены классом MenuItem и составляют набор ObservableList, заполнить который можно с помощью метода getItems.addAll класса ContextMenu.

С элементами MenuItem мы уже познакомились при обсуждении панели MenuBar.

Контекстное меню прикрепляется к элементу управления методом setContextMenu.

Отдельно отобразить контекстное меню можно методом show, а скрыть его методом hide.

В этом примере мы создаем контекстное меню с элементом Remove и прикрепляем его к дереву.

При нажатии правой кнопкой мышки на дереве появляется контекстное меню.

При активации элемента Remove выделенный узел дерева удаляется.

Отличие набора свойств компонента MenuButton от набора свойств компонента Button заключается в наличии свойств popupSide и showing.

Свойство popupSide определяет расположение меню относительно кнопки, а свойство showing принимает значение true при отображении меню.

При создании компонента MenuButton требуется создание меню, являющегося неотъемлемой частью компонента.

При этом меню состоит из набора компонентов, представленных классом MenuItem, пополнять который можно с помощью метода getItems.addAll класса MenuButton.

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

С классом MenuItem мы уже познакомились при обсуждении панели MenuBar.

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

С помощью метода setPopupSide мы определяем, что меню будет располагаться справа.

Далее мы создаем элементы меню MenuItem, к которым присоединяем обработчик выбора, используя метод setOnAction.

И добавляем элементы меню к кнопке методом getItems.addAll.

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

Компонент SplitMenuButton по своей функциональности аналогичен компоненту MenuButton, так как класс SplitMenuButton является расширением класса MenuButton.

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

Меню компонента SplitMenuButton состоит из набора компонентов, представленных классом MenuItem, пополнять который можно с помощью метода getItems.addAll класса MenuButton.

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

Для этого нужно использовать отдельные методы setText и setGraphic.

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

К кнопке мы присоединяем обработчик нажатия с помощью метода setOnAction.

Далее мы создаем элементы меню MenuItem, к которым присоединяем обработчик выбора, используя метод setOnAction.

И добавляем элементы меню к кнопке методом getItems.addAll.

Компонент ColorPicker состоит из компонента выбора цвета, компонента цветовой палитры и настраиваемого диалогового окна цветов.

Компонент выбора цвета представляет собой поле со списком цветов для выбора цвета.

Реализация этого компонента позволяет три вида компонента выбора цвета: кнопка, разделенная кнопка с меню и поле со списком по умолчанию.

Чтобы изменить поле со списком на кнопку или разделенную кнопку, нужно применить соответствующий CSS класс с помощью метода getStyleClass.add.

Компонент цветовая палитра содержит предопределенный набор цветов и ссылку «Пользовательский цвет», которая открывает диалоговое окно «Пользовательский цвет».

Если пользовательский цвет уже определен, этот цвет отображается в области «Пользовательский цвет» в цветовой палитре.

Цветовая палитра поддерживает навигацию с помощью клавиш «Вверх», «Вниз», «Влево» и «Вправо».

Набор пользовательских цветов не перезагружается, когда приложение запускается снова, если этот набор явно не сохраняется в приложении.

Диалоговое окно «Пользовательский цвет» – это модальное окно, которое можно открыть, щелкнув ссылку в цветовой палитре.

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

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

Другой способ определить новый цвет – установить значения яркости HSB или RGB, или явно ввести значение цвета в соответствующем поле.

Пользователь также может установить прозрачность пользовательского цвета.

Когда новый цвет выбран, пользователь может нажать «Использовать», чтобы применить его, или «Сохранить», чтобы сохранить цвет.

В этом примере мы создаем компонент ColorPicker с помощью конструктора, в которм сразу можно указать выбранный цвет.

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

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

Компонент DatePicker состоит из поля даты и списка выбора даты.

Программный интерфейс Date-Time, введенный в JDK 8, позволяет выполнять различные операции с датой и временем, включая настройку календарного и местного времени для разных часовых поясов.

Основным пакетом программного интерфейса Date-Time является пакет java. time.

Чтобы улучшить пользовательский интерфейс JavaFX с возможностями API Date-Time, в JavaFX SDK был введен элемент управления DatePicker, который состоит из редактируемого поля даты и календаря выбора даты.

В исходном состоянии поле даты пустое.

Можно указать начальное значение даты, с помощью метода setValue компонента, или указав дату в конструкторе.

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

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

Вы можете включить или отключить отображение номеров недели в календаре с помощью метода setShowWeekNumbers класса DatePicker.

По умолчанию даты в поле даты отображаются в формате мм / дд / гггг.

Обычно вам не нужно изменять этот формат по умолчанию.

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

Метод setPromptText позволяет установить подсказку в поле даты.

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

С помощью метода setOnAction мы присоединяем к DatePicker обработчик выбора даты, в котором получаем выбранную пользователем дату и используем ее.

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

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

Класс FileChooser находится в пакете javafx.stage вместе с другими корневыми компонентами, такими как Stage, Window и Popup.

Класс FileChooser представляет окно выбора файлов локальной файловой системы и имеет свойства initialDirectory и title.

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

Свойство title позволяет установить заголовок окна FileChooser.

Методы showOpenDialog, showSaveDialog и showOpenMultipleDialog класса FileChooser отображают окно открытия файла, сохранения файла и открытия сразу нескольких файлов и при этом оперируют объектами java.io.File.

Метод getExtensionFilters класса FileChooser дает возможность установить фильтр файловых расширений для окна FileChooser.

Здесь показан пример использования компонента FileChooser для загрузки изображения.

Мы создаем компонент FileChooser с помощью конструктора и методом setInitialDirectory устанавливаем открываемый каталог.

По умолчанию открывается каталог Компьютер.

Далее методом getExtensionFilters.add мы добавляем фильтры расширений файлов для выбора пользователем.

По умолчанию какой-либо фильтр отсутствует.

Метод showOpenDialog возвращает выбранный пользователем файл в виде объекта java.io.File.

Из этого объекта мы извлекаем путь изображения и используем его для создания объекта Image и компонента ImageView.

Для сохранения в файл, вызывается метод showSaveDialog компонента FileChooser.

Здесь мы используем класс ImageIO пакета javax.imageio для записи изображения.

Статический метод write класса ImageIO записывает изображение, на основе объекта java.awt.Image, формата изображения и объекта java.io.File.

Формат изображения и объект java.io.File нам известны из метода showSaveDialog.

Чтобы получить объект java.awt.Image, мы используем класс SwingFXUtils, который обеспечивает преобразования типов данных между форматами Swing / AWT и JavaFX.

Компонент FileChooser позволяет выбрать только файл, а не каталог.

Для выбора каталога предназначен компонент DirectoryChooser.

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

Метод showDialog возвращает выбранный каталог в виде объекта java.io.File.

В методе start главного класса JavaFX-приложения можно не использовать объект Stage, передаваемый методу start в качестве аргумента, а создать свой объект Stage с помощью конструктора класса Stage.

При этом можно определить стиль создаваемого окна, используя поля DECORATED, TRANSPARENT, UNDECORATED и UTILITY перечисления StageStyle.

После создания объекта Stage, его свойство title дает возможность установить заголовок окна, свойство fullScreen – перевести окно в полноэкранный режим, свойство iconified – свернуть окно, а свойство resizable – отменить возможность изменения размеров окна пользователем.

Метод setScene устанавливает сцену для объекта Stage, а метод show делает окно видимым.

С помощью метода close можно закрыть окно,

методом initModality – можно установить модальность окна,

методом initOwner – можно установить родительское окно,

методом initStyle – определить декорирование окна,

а методы toBack и toFront позволяют перемещать окно на задний или передний план.

Класс Screen пакета stage позволяет получить характеристики экрана устройства и привязать окно Stage к размерам экрана.

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

Для этого в качестве корневого узла графа сцены удобно назначить панель с прокруткой ScrollPane.

Однако панель ScrollPane может содержать только один дочерний узел, поэтому в качестве дочернего узла для панели ScrollPane можно установить контейнер Group или Pane.

Для контейнера Group нет возможности установить размеры методом setPrefSize, поэтому удобнее использовать контейнер Pane.

При этом важно установить размеры контейнера Pane чуть больше, чем размеры Scene-сцены, чтобы при прокрутке корневой панели ScrollPane видеть все узлы графа сцены.

Так как панель ScrollPane по умолчанию имеет серый фон, поэтому для изменения фона сцены можно использовать стиль -fx-background: white.

Поменять сторону полосы прокрутки панели ScrollPane с правой на левую можно методом setNodeOrientation с параметром NodeOrientation. RIGHT_TO_LEFT.

При этом к дочернему узлу панели нужно применить метод setNodeOrientation с параметром NodeOrientation. LEFT_TO_RIGHT.

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

Всплывающее окно Popup может содержать набор узлов, пополнить который можно с помощью метода getContent.addAll класса Popup.

Отображается или скрывается окно Popup с помощью вызова методов show или hide.

А опция автоматического исчезновения окна при потере фокуса устанавливается определением свойства autoHide.

Координаты отображения окна Popup устанавливаются с помощью определения свойств x и y.

В этом примере мы создаем окно Popup.

Методом setAutoHide (true) устанавливаем для этого окна автоматическое закрытие при потере фокуса.

Добавляем в это окно узлы.

И в обработчике нажатия кнопки, мы привязываем координаты окна к курсору мыши при нажатии.

Методом show мы отображаем окно Popup.

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

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

Поэтому типом здесь будет объект Pair, класс пакета javafx. util, представляющий пару имя-значение.

Именно этот объект и будет возвращать диалоговое окно, чтобы мы могли в приложении получить введенные пользователем логин и пароль.

Метод setTitle устанавливает заголовок диалогового окна, а методы setHeaderText и setGraphic устанавливают текст и значок заголовка содержимого окна.

Заголовок окна также может быть представлен узлом с помощью метода setHeader.

Метод getDialogPane возвращает панель DialogPane, которая служит корневым узлом диалога.

Эта панель содержит текст или узел и значок заголовка содержимого окна, а также контент и кнопки окна.

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

Контент окна также может быть представлен текстом или узлом, используя методы setContentText или setContent.

Кнопки добавляются в панель DialogPane методом getButtonTypes.addAll, используя типы кнопок ButtonType.

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

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

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

Методом showAndWait мы открываем окно и получаем введенные пользователем данные.

Метод show компонента Dialog открывает не модальное окно, которое не возвращает результат.

С помощью метода initOwner для диалога можно установить пользовательское родительское Stage окно, для которого можно определить свой значок.

Методом initStyle можно установить стиль окна.

А методом initModality можно установить модальность окна.

Класс Dialog расширяется классами Alert, ChoiceDialog, TextInputDialog, которые представляют специализированные диалоговые окна.

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

Типы INFORMATION, WARNING и ERROR не предполагают возврата какого-либо результата диалогом.

Установив тип CONFIRMATION для диалога Alert, можно получить результат диалога от пользователя.

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

Для выбора пользователем предустановленных опций можно использовать диалог ChoiceDialog.

Здесь вы в конструкторе диалога, либо методом getItems.addAll определяете список выбора.

И методом showAndWait получаете выбранный пользователем вариант.

Компонент Pagination состоит из содержимого страницы и управления навигацией между страницами.

Компонент Pagination создается с помощью конструктора, в котором можно указать количество страниц контента и индекс открытой страницы.

Количество страниц контента и индекс открытой страницы также можно указать методами setPageCount и setCurrentPageIndex.

Ограничить количество отображаемых кнопок страниц в компоненте можно методом setMaxPageIndicatorCount.

Контент страниц компонента Pagination заполняется с помощью фабрики, которая устанавливается методом setPageFactory.

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

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

На основе количества фрагментов мы рассчитываем, сколько у нас будет страниц и передаем эту цифру в конструктор компонента Pagination.

Методом setMaxPageIndicatorCount мы устанавливаем, что в панели навигации будет отображаться только 5 кнопок.

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

Любой узел Node может быть аннотирован с помощью метода setButtonData и помещен в панель ButtonBar, с помощью метода getButtons.addAll.

При этом размещение этого узла относительно других узлов будет определяться на основе его аннотации, а также общего порядка кнопок, определенного для панели ButtonBar.

Общий порядок кнопок устанавливается для панели ButtonBar устанавливается методом setButtonOrder с использованием констант BUTTON_ORDER_WINDOWS, BUTTON_ORDER_MAC_OS, и BUTTON_ORDER_LINUX, и является специфическим для конкретной операционной системы.

Например, для Windows порядка, кнопка с аннотацией Yes появится перед кнопкой с аннотацией No, тогда как для Linux и Mac OS порядка это будет наоборот.

По умолчанию все кнопки имеют одинаковый размер в панели ButtonBar, и это означает, что все кнопки имеют ширину самой широкой кнопки.

Вы можете отказаться от этого для каждой кнопки, вызывая метод setButtonUniformSize со значением false.

Панель SplitPane содержит набор дочерних узлов ObservableList, заполнить который можно с помощью метода getItems.addAll класса SplitPane.

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

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

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

Задавать расположение разделителей частей панели SplitPane можно с помощью метода setDividerPosition или методом setDividerPositions, или заполняя набор ObservableList разделителей методом getDividers.addAll.

Позиция разделителя представляет собой число между 0.0 и 1.0.

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

Спиннер похож на комбинированное поле combo box и список, которые позволяют пользователю выбирать из диапазона значений.

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

Но в отличие от комбинированных полей combo box, у спиннеров нет раскрывающегося списка.

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

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

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

Это IntegerSpinnerValueFactory для последовательности целых значений.

DoubleSpinnerValueFactory для последовательности значений типа double.

И ListSpinnerValueFactory для последовательности значений ObservableList, это обычно значения типа String.

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

По умолчанию Spinner не редактируется, но это можно изменить, если для свойства editable установить значение true.

Редактор Spinner синхронизируется с фабрикой SpinnerValueFactory, слушая изменения свойства value фабрики значений.

Если пользователь изменил значение, отображаемое в редакторе, пользователь должен зафиксировать редактирование с помощью клавиши «Enter».

На слайде показано создание спиннеров для трех типов значений – int, double и String.

Для создания спиннера с последовательностью произвольных объектов, создается фабрика SpinnerValueFactory с переопределенными методами decrement и increment, а объект должен иметь переопределенный метод toString.

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

Для создания редактируемого спиннера, сначала мы должны вызвать метод setEditable (true).

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

Делаем мы это методом setConverter, в котором указываем преобразователь с определенными методами toString и fromString.

Далее мы присоединяем к полю спиннера, которое является редактором, слушатель нажатия клавиши Enter.

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

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

Если такое значение уже есть, мы устанавливаем его как текущее.

Для последовательности типа String, все это уже определено по умолчанию.

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

Задание

Создайте спиннер с использованием модели данных и пользовательской фабрикой значений.

Свойство компонента orientation определяет горизонтальное или вертикальное расположение панели инструментов.

Панель ToolBar содержит набор дочерних узлов ObservableList, заполнить который можно с помощью метода getItems.addAll класса ToolBar.

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

Панель TabPane состоит из набора закладок ObservableList, заполнить который можно с помощью метода getTabs.addAll класса TabPane.

Закладки панели TabPane представлены классом Tab, экземпляр которого может быть создан с помощью конструктора, в котором можно сразу указать заголовок закладки и узел контента.

Класс Tab обеспечивает отображение узла Node в пределах панели TabPane и имеет набор свойств.

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

Остальные свойства обеспечивают оформление и поведение кнопки закладки.

Свойство side класса TabPane позволяет поместить кнопки закладок на верхней, нижней, левой или правой стороне панели TabPane.

Свойство tabClosingPolicy определяет возможность закрытия закладок.

Свойства tabMaxHeight, tabMaxWidth, tabMinHeight, tabMinWidth дают возможность установить размеры кнопок закладок.

В этом примере мы создаем панель с закладками.

Методом setPrefSize устанавливаем размеры панели.

Методом setSide устанавливаем расположение кнопок закладок в верхней части панели.

Методом setTabClosingPolicy устанавливаем, можно ли закрывать закладки.

Методами setTabMinHeight и setTabMinWidth устанавливаем размеры кнопок закладок.

Далее мы создаем сами закладки, для которых методом setContent устанавливаем узел отображаемого контента.

И добавляем закладки в панель методом getTabs.addAll.

Объект ImageView создается на основе объекта изображения, представленного классом Image, экземпляр которого может быть создан с помощью конструкторов.

Здесь видно, что изображение Image может быть загружено на основе входящего потока InputStream или URL адреса изображения.

Загрузка изображения также может быть выполнена с учетом параметров – это размеры изображения и его сглаживание при масштабировании.

Класс Image используется для загрузки изображения и имеет свойства для чтения: error, exception, height, progress, и width.

Свойства error и exception позволяют обработать ошибку загрузки изображения.

Свойства height и width позволяют получить размер загруженного изображения.

А свойство progress позволяет отследить процесс загрузки изображения.

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

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

Для свойства progress, мы связываем его значение со значением свойства progress индикатора загрузки.

После загрузки изображения мы устанавливаем его в узел ImageView методом setImage.

Свойства узла ImageView fitHeight и fitWidth позволяют подогнать загруженное изображение под указанные размеры, а свойство preserveRatio – сохранить при этом его пропорции.

Свойство smooth обеспечивает сглаживание при трансформации изображения,

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

В отличие от свойства viewport, которое маскирует исходное изображение, свойство clip класса Node определяет маску самого узла ImageView.

При одновременном определении свойств x, y со свойствами layoutX, layoutY их значения складываются в конечные координаты узла ImageView в родительском узле Node.

Здесь показан пример создания узла ImageView.

Методами setFitHeight и setFitWidth мы подгоняем размеры изображения под указанные, при этом методом setPreserveRatio сохраняем исходные пропорции изображения.

Теперь, предположим у нас стоит задача загрузить изображение в узел ImageView.

Затем применить к этому узлу различные трансформации и эффекты.

И мы хотим сохранить этот узел обратно как изображение.

Как нам это сделать?

Первый способ сделать это – это использовать класс Robot пакета java.awt.

В этом случае создается скриншот участка экрана компьютера, который сохраняется в объект BufferedImage пакета java.awt.image.

В этом коде мы вычисляем координаты контейнера, в котором находится узел ImageView.

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

Затем методом createScreenCapture класса Robot создаем скриншот экрана внутри этого прямоугольника.

И сохраняем этот скриншот в файл.

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

Другой способ сохранения изображения – это применить к узлу графа сцены метод snapshot класса Node, возвращающий объект WritableImage пакета scene.image, который можно конвертировать в объект BufferedImage пакета awt.image методом fromFXImage класса SwingFXUtils.

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

При этом технология отображения Web-контента платформы JavaFX основана на проекте WebKit Open Source Project.

Класс WebView представляет узел отображения Web-контента, а класс WebEngine загружает веб-страницу, применяет стили и запускает JavaScript на странице.

С помощью свойства fontScale класса WebView можно регулировать размер шрифта на отображаемой Web-странице.

Свойства height, maxHeight, maxWidth, minHeight, minWidth, prefHeight, prefWidth и width определяют размеры встроенного Web-браузера WebView.

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

За загрузку отображаемой узлом WebView Web-страницы отвечает создаваемый средой выполнения объект WebEngine.

Доступ к объекту WebEngine можно получить с помощью метода getEngine класса WebView.

При этом объект WebEngine имеет набор свойств.

Свойство location возвращает URL-адрес отображаемой Web-страницы, а свойства title и document обеспечивают доступ к заголовку и документу Web-страницы.

Свойства confirmHandler, createPopupHandler, onAlert, onResized, onStatusChanged, onVisibilityChanged и promptHandler обеспечивают обработку событий Web-страницы.

За асинхронную загрузку Web-страницы на основе URL-адреса отвечает метод load класса WebEngine, а за обновление Web-страницы – метод reload.

Метод loadContent класса WebEngine позволяет отобразить Web-станицу на основе строки HTML-разметки.

Методы getLoadWorker и executeScript класса WebEngine позволяют отследить прогресс загрузки Web-страницы и выполнить JavaScript-код в контексте загруженной Web-страницы.

Объект Worker, возвращаемый методом getLoadWorker – это объект, который выполняет работу в одном или нескольких фоновых потоках, и его состояние является наблюдаемым и доступным и может использоваться из основного потока приложения.

Фоновые вычисления JavaFX мы рассмотрим позднее.

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

Мы создаем узел WebView, устанавливаем его размеры, методом getEngine получаем созданный средой выполнения объект WebEngine и загружаем первоначальный HTML контент.

Далее мы создаем текстовое поле для ввода веб адреса.

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

Здесь мы присоединили слушатель свойства location WebEngine, и как только открывается новая страница, ее адрес автоматически отображается в текстовом поле.

Также мы создали индикатор загрузки веб станицы.

Для WebEngine мы получаем фоновую задачу Worker и присоединяем к ней слушатель свойства progress.

Пока значение этого свойства не становится равным 1, мы видим круговой индикатор.

С помощью метода print WebEngine можно распечатать веб страницу.

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

Объект PrinterJob создается с помощью статического метода createPrinterJob.

Метод printPage объекта PrinterJob позволяет распечатать любой узел Node.

Однако класс WebEngine реализует свой метод print на основе объекта PrinterJob.

Метод showPageSetupDialog объекта PrinterJob показывает диалог настройки макета страницы для печати, а метод showPrintDialog показывает диалог настройки принтера.

Узел MediaView отвечает за отображение медиа контента, компонент MediaPlayer – за его проигрывание, а компонент Media – за загрузку видео и аудио файлов.

Так как платформа JavaFX поддерживает воспроизведение видео только в формате FLV и MPEG-4, необходимо предварительно конвертировать видео файлы в этот формат для их использования в JavaFX-приложении.

Для воспроизведения аудио клипов в JavaFX-приложениях можно использовать форматы MP3, AIFF и WAV.

С помощью свойств fitHeight и fitWidth класса MediaView можно подогнать воспроизводимый видео контент под указанные размеры,

а свойства preserveRatio и smooth позволяют при этом сохранить его пропорции и обеспечить сглаживание.

Свойство viewport определяет маску исходного видео контента,

свойство onError – обработчик события ошибки MediaErrorEvent,

свойства x и y – координаты в родительском узле.

Узел MediaView создается на основе невизуального компонента MediaPlayer, отвечающего за проигрывание медиа контента,

и свойство mediaPlayer как раз связывает компонент MediaPlayer с узлом MediaView.

Класс MediaPlayer имеет большой набор свойств.

Свойство error определяет объект MediaException, представляющий ошибку воспроизведения медиаконтента,

а свойство onError – определяет обработчик Runnable ошибки воспроизведения медиаконтента.

С помощью свойств onMarker, onEndOfMedia, onReady, onPlaying, onPaused, onStopped, onHalted, onRepeat и onStalled устанавливаются обработчики Runnable состояний плеера.

Если свойство autoPlay определяется со значением true, тогда воспроизводство медиаконтента начинается сразу по готовности плеера.

Свойства rate, volume, balance, startTime, stopTime, cycleCount, mute, audioSpectrumNumBands, audioSpectrumInterval, audioSpectrumThreshold определяют скорость проигрывания, громкость, баланс, задержку начала проигрывания и задержку окончания проигрывания, количество циклов проигрывания, выключение звука, число полос в звуковом спектре, интервал между обновлениями аудиоспектра, порог воспроизведения звука.

Свойства currentRate, cycleDuration, totalDuration, currentTime, status, bufferProgressTime, currentCount возвращают текущую скорость проигрывания, продолжительность цикла проигрывания, общую продолжительность проигрывания, текущее время проигрывания, состояние плеера UNKNOWN, READY, PAUSED, PLAYING, STOPPED, STALLED и HALTED, количество данных Duration буфера плеера, а также текущий цикл проигрывания.

С помощью свойства audioSpectrumListener устанавливается объект AudioSpectrumListener, обрабатывающий обновления аудиоспектра и используемый для его визуализации при проигрывании медиаконтента.

Методы pause, play, seek и stop класса MediaPlayer обеспечивают паузу, проигрывание, перемещение и остановку медиа плеера.

Медиа плеер MediaPlayer создается на основе невизуального компонента Media, отвечающего за загрузку видео и аудио файлов.

Объект Media создается на основе URI адреса источника медиа.

Класс Media имеет свойства для чтения duration, error, height и width, а также свойство onError, определяющее обработчик Runnable события ошибки загрузки медиаконтента.

Приведенный код демонстрирует воспроизведение медиаконтента.

Здесь создаются два плеера MediaPlayer, один из которых воспроизводит видео файл, а другой – аудио файл.

Плеер MediaPlayer, воспроизводящий видео файл, добавляется в узел MediaView.

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

Здесь в обработчиках действия кнопок используются методы плеера play, pause, stop, seek, setVolume.

Метод seek перемещает плеер в указанную временную метку воспроизведения.

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

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

Что касается 3D-форм, в JavaFX есть два типа трехмерных фигур – это предопределенные фигуры, и пользовательские фигуры.

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

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

Для сцены есть метод getCamera, который возвращает объект Camera, камеру, установленную для сцены.

Если камера не установлена для сцены, тогда этот метод вернет нуль.

То есть среда выполнения сама не устанавливает объект камеры по умолчанию.

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

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

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

Однако для сцены мы можем установить свою камеру методом setCamera.

Камера в JavaFX представлена абстрактным классом Camera, который имеет две реализации – параллельная камера и камера с перспективой.

Камера имеет два свойства – расстояние от глаз до передней плоскости отсечения и расстояние от глаз до дальней плоскости отсечения.

Расстояние до дальней плоскости отсечения регулирует, сколько объектов вы захватите в сцене. По умолчанию это значение равно 100.

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

Надо отметить, что плоскость проекции, в нашем случае, не совпадает с передней плоскостью отсечения.

Плоскость проекции находится в точке Z = 0.

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

Кроме того, в конструкторе камеры определяется параметр fixedEyeAtCameraZero.

По умолчанию, fixedEyeAtCameraZero имеет значение false, и при изменении размера сцены объекты в сцене на плоскости проекции (в координате Z = 0) будут иметь тот же размер, но для просмотра будет доступно больше или меньше содержимого сцены, то есть будет изменяться положение глаз.

Здесь у нас этот параметр имеет значение false, и при увеличении размера сцены мы начинаем видеть другие поверхности куба.

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

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

Что касается угла fieldOfView, так как расстояние по оси Z от камеры до плоскости проекции определяется шириной и высотой сцены, и ее углом fieldOfView, то при увеличении этого угла методом setFieldOfView, который по умолчанию имеет значение 30, объекты цены становятся дальше от камеры.

Если использовать параллельную камеру, ее можно двигать по осям X и Y, смещая отображение сцены.

Двигать параллельную камеру по оси Z не имеет смысла.

Сцена может использовать только одну камеру.

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

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

Поэтому JavaFX предоставляет возможность создавать подсцены.

Подсцена – это контейнер для графа сцены. Он может иметь собственные характеристики, такие как, собственная ширина, высота, цвет заливки, и так далее.

Подсцена наследует класс Node.

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

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

Для этой подсцены мы устанавливаем перспективную камеру.

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

В корневой узел основной сцены, мы также добавляем подсцену.

Форма Shape3D имеет свойство material, которое определяет материал поверхности формы.

Материал используется для визуализации поверхности 3D фигур.

Материал представлен абстрактным классом Material, который имеет реализацию в виде класса PhongMaterial.

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

В качестве карты bumpMap может использоваться изображение, представленное объектом Image.

Свойства diffuseColor и specularColor определяют цвета света, отраженного от шероховатой поверхности и гладкой поверхности соответственно.

Вместо свойств diffuseColor и specularColor можно использовать свойства diffuseMap и specularMap, определяющие карты рассеянного и отраженного света.

Можно также использовать свойство selfIlluminationMap, карту самоосвещения, которая делает поверхности объекта светящимися.

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

По умолчанию, форма Shape3D имеет материал PhongMaterial с диффузным цветом Color.LIGHTGRAY.

В наших примерах мы использовали для освещения 3D формы источник света PointLight, источник света, который находится в фиксированной точке в пространстве и излучает свет одинаково во всех направлениях от себя.

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

Оба эти источника света имеют свойство цвета и свойства быть включенным или выключенным.

С помощью объекта PickResult, который возвращается методом getPickResult, и представляет контейнер, содержащий результат события выбора, можно получить выбранную пользователем 3D форму в обработчике события, чтобы с ней работать.

Помимо куба можно использовать другие предопределенные 3D формы – цилиндры и сферы.

В конструкторе сферы указывается радиус сферы и можно указать количество секторов.

Трехмерная сфера состоит из множества секторов, которые построены из связанных треугольников.

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

В конструкторе цилиндра указываются его радиус и высота.

Также можно указать количество секторов.

Поверхность 3D-формы состоит из множества связанных многоугольников, состоящих из треугольников.

Например, куб состоит из 12 треугольников. Каждая сторона куба использует два треугольника.

Свойство drawMode класса Shape3D указывает, как визуализируется поверхность 3D-фигур.

С помощью константы LINE и метода setDrawMode можно отобразить только контур треугольников. То есть только линии, соединяющие вершины последовательных треугольников.

С помощью константы FRONT и метода setCullFace можно посмотреть на внутренние поверхности 3D-фигуры.

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

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

По умолчанию, CullFace.BACK указывает, что все треугольники, которые не могут быть видны через камеру в ее текущем положении, должны быть отброшены. То есть все треугольники, внешние поверхности которых не обращены к камере, должны быть отброшены.

С помощью класса MeshView можно создавать пользовательские 3D фигуры.

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

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

Класс TriangleMesh является конкретным подклассом класса Mesh.

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

Предоставление данных сетки вручную – это непростая задача.

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

Описать координаты текстуры для каждой вершины.

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

Определить группу сглаживания, к которой принадлежит каждая поверхность.

С помощью свойства title класса Chart устанавливается заголовок диаграммы, а с помощью свойства titleSide – расположение заголовка вверху, внизу, справа или слева самой диаграммы.

Свойства legendSide и legendVisible определяют расположение и видимость панели пояснений к диаграмме.

Если свойство animated установить со значением true, тогда диаграмма будет динамически реагировать на изменения своих свойств.

В то время как класс PieChart напрямую расширяет класс Chart, классы AreaChart, BarChart, BubbleChart, LineChart, ScatterChart, StackedAreaChart, StackedBarChart являются подклассами класса XYChart, расширяющего класс Chart.

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

Свойства alternativeColumnFillVisible и alternativeRowFillVisible определяют выделение через один в сетке диаграммы столбцов и строк, если оба свойства установлены со значением true, сетка диаграммы похожа на шахматную доску.

Свойства verticalGridLinesVisible и horizontalGridLinesVisible определяют отображение вертикальных и горизонтальных линий сетки диаграммы, а свойства verticalZeroLineVisible и horizontalZeroLineVisible – отображение дополнительных вертикальных и горизонтальных линий нулевых отметок при условии отображения вертикальных и горизонтальных линий сетки диаграммы.

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

Заполнить набор ObservableList данных диаграммы можно с помощью метода getData.addAll класса XYChart.

Данные диаграммы XYChart представлены классом XYChart.Series.

Класс XYChart.Series представляет серию данных диаграммы XYChart и имеет свойства: chart, data, name, node.

Свойство name определяет название серии, отображаемое в панеле пояснений к диаграмме.

После того как серия добавляется в набор данных диаграммы XYChart, формируется узел Node, отвечающий за отображение серии, и с помощью свойства node можно получить доступ к свойствам этого узла.

Свойство data определяет набор ObservableList данных серии, заполнить который можно с помощью метода getData.addAll класса XYChart.Series.

Данные серии XYChart.Series представлены классом XYChart. Data.

Класс XYChart. Data представляет данные серии XYChart.Series и имеет свойства: extraValue, node, xValue, yValue.

Свойства xValue и yValue определяют значение элемента данных по оси X и Y, свойство extraValue – дополнительное значение, например, радиус для кружковой диаграммы.

После того как элемент данных добавляется в набор данных диаграммы XYChart, формируется узел Node, отвечающий за отображение элемента данных, и с помощью свойства node можно получить доступ к свойствам этого узла.

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

Оси диаграммы XYChart представлены базовым классом Axis и его подклассами CategoryAxis и NumberAxis.

Свойство label класса Axis определяет подпись оси, а свойство side – сторону отображения оси.

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

Если свойство animated установить со значением true, тогда ось будет динамически реагировать на изменения своих свойств.

Свойства tickLabelFill, tickLabelFont, tickLabelGap, tickLabelRotation, tickLabelsVisible, tickLength и tickMarkVisible определяют цвет подписей к меткам оси, шрифт подписей к меткам оси, интервал между линиями меток на оси и подписями к меткам оси, поворот подписей к меткам оси, отображение подписей меток оси, длину линий меток на оси и отображение меток оси.

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

Набор строковых значений ObservableList оси CategoryAxis может быть создан с помощью статического метода observableArrayList класса FXCollections.

Класс CategoryAxis имеет, помимо унаследованных от класса Axis, собственные свойства categorySpacing, endMargin, gapStartAndEnd, и startMargin, определяющие интервал между метками, интервал между последней меткой и окончанием оси, распределение половины расстояния между метками на начало и конец оси и интервал между началом оси и первой меткой.

Класс NumberAxis представляет числовую ось диаграммы XYChart.

Класс NumberAxis имеет, помимо унаследованных от класса Axis, свойства, унаследованные от класса ValueAxis.

И собственные свойства forceZeroInRange и tickUnit.

Свойства lowerBound, minorTickCount, minorTickLength, minorTickVisible, tickLabelFormatter и upperBound позволяют определить минимальное значение оси, количество вспомогательных меток, длину вспомогательных меток, отображение вспомогательных меток, форматирование подписей к меткам оси и максимальное значение оси.

Свойства forceZeroInRange и tickUnit определяют включение нулевой метки в видимый диапазон при его автонастройке и интервал между главными метками оси.

Круговая диаграмма представлена классом PieChart.

Класс PieChart представляет круговую (секторную) диаграмму и имеет, помимо унаследованных от класса Chart, собственные свойства.

Свойство data определяет набор ObservableList данных, из которых формируются сектора диаграммы, подписи к ним и содержимое панели пояснений к диаграмме.

Набор данных ObservableList диаграммы PieChart может быть создан с помощью статического метода observableArrayList класса FXCollections.

При этом данные диаграммы PieChart представляются классом PieChart. Data.

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

Получить доступ к свойствам узла Node, представляющего сектор PieChart. Data, позволяет метод getNode класса PieChart. Data, а к свойствам самой диаграммы PieChart, к которой относится сектор, – метод getChart класса PieChart. Data.

С помощью свойства clockwise класса PieChart устанавливается расположение секторов диаграммы по часовой стрелке, а с помощью свойства startAngle – угол начала первого сектора диаграммы.

Свойства labelsVisible и labelLineLength определяют отображение подписей к секторам диаграммы и длину линии от сектора диаграммы до подписи к сектору.

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

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

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

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

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

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

Класс AreaChart имеет, помимо унаследованных от класса Chart, свойства, унаследованные от класса XYChart.

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

Для диаграммы AreaChart создаются горизонтальная ось CategoryAxis и вертикальная ось NumberAxis, для которых определяются такие свойства как подпись оси, цвет подписей к меткам оси и так далее.

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

Для диаграммы AreaChart создаются две серии данных, для одной из которых устанавливается визуальный эффект.

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

И заполняем серию данными с использованием этих узлов.

При этом числовые данные оси Y привязываются к строковым категориям оси X.

Диаграмма StackedAreaChart – это вариация диаграммы AreaChart, в которой области накладываются таким образом, что на вертикальной оси отображаются кумулятивные значения в любой заданной точке вдоль горизонтальной оси.

То есть значения на верхней кривой – здесь, это суммарные значения двух серий.

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

Методом chartArea.setCreateSymbols (false) можно убрать узлы значений, превратив кривые в тренды.

Класс BarChart представляет диаграммы-прямоугольники, заполненные разными цветами и сгруппированные по разным категориям.

Одна ось диаграммы BarChart должна быть CategoryAxis, а другая – NumberAxis.

Если ось CategoryAxis является горизонтальной осью, тогда диаграмма BarChart содержит вертикальные столбики.

Если же ось CategoryAxis является вертикальной осью, тогда диаграмма BarChart состоит из горизонтальных полос.

Класс BarChart имеет, помимо унаследованных от класса Chart, свойства, унаследованные от класса XYChart и собственные свойства barGap и categoryGap, определяющие интервалы между прямоугольниками в одной категории и разными категориями.

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

Для диаграммы BarChart создаются горизонтальная ось CategoryAxis и вертикальная ось NumberAxis, для которых определяются такие свойства как подпись оси, цвет подписей к меткам оси и так далее.

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

Для диаграммы BarChart создаются две именованные серии данных.

И эти серии добавляются в диаграмму.

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

То есть значения столбиков – это суммарные значения серий.

В этой диаграмме нужно внимательно устанавливать верхнее ограничение значений по числовой оси.

Кроме того, в этой диаграмме отсутствует свойство barGap, есть только свойство categoryGap.

Класс BubbleChart представляет пузырьковую диаграмму с числовыми осями NumberAxis.

Класс BubbleChart имеет, помимо унаследованных от класса Chart, свойства, унаследованные от класса XYChart.

Для диаграммы BubbleChart можно использовать свойство extraValue класса XYChart. Data, с помощью которого можно регулировать размер пузырька диаграммы.

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

Для диаграммы BubbleChart создаются горизонтальная и вертикальная оси NumberAxis, для которых определяются такие свойства как подпись оси, цвет подписей к меткам оси и так далее.

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

Для диаграммы BubbleChart создаются три именованные серии данных, элементы которых после добавления в диаграмму масштабируются по вертикали.

Класс LineChart представляет диаграммы двухмерных графиков, которые отличаются от диаграмм AreaChart тем, что области под графиками не выделены цветом.

Класс LineChart имеет, помимо унаследованных от класса Chart, свойства, унаследованные от класса XYChart и собственное свойство createSymbols.

Если свойство createSymbols установлено со значением false, тогда элементы данных никак не выделяются на графике, который отображается в виде тренда.

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

Для диаграммы LineChart создаются горизонтальная ось CategoryAxis и вертикальная ось NumberAxis, для которых определяются такие свойства как подпись оси, цвет подписей к меткам оси и так далее.

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

Для диаграммы LineChart создаются две именованные серии данных.

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

И заполняем серию данными с использованием этих узлов.

При этом числовые данные оси Y привязываются к строковым категориям оси X.

В конце серии добавляются в диаграмму.

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

Класс ScatterChart имеет, помимо унаследованных от класса Chart, свойства, унаследованные от класса XYChart.

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

Для диаграммы ScatterChart создаются горизонтальная и вертикальная оси NumberAxis, для которых определяются такие свойства как подпись оси, цвет подписей к меткам оси и так далее.

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

Для диаграммы ScatterChart создаются две именованные серии данных.

И эти серии добавляются в диаграмму.

Граф сцены JavaFX, представляющий графический пользовательский интерфейс приложения JavaFX, не является потокобезопасным и может быть доступен и изменен только из потока пользовательского интерфейса JavaFX Application Thread.

Реализация долго выполняющихся задач в потоке приложения JavaFX неизбежно делает пользовательский интерфейс приложения невосприимчивым.

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

Работу с фоновыми потоками пакет concurrent обеспечивает с помощью двух абстрактных классов Task и Service, реализующих интерфейс Worker.

Интерфейс Worker определяет объект, который выполняет некоторую работу в одном или нескольких фоновых потоках.

Состояние объекта Worker является наблюдаемым и может использоваться из потока приложения JavaFX.

Жизненный цикл объекта Worker определяется следующим образом.

При создании объект Worker находится в состоянии READY.

При планировании работы объект Worker переходит в состояние SCHEDULED.

После этого, когда объект Worker выполняет работу, его состояние становится RUNNING.

Даже когда объект Worker немедленно запускается без планирования, он сначала переходит в состояние SCHEDULED, а затем в состояние RUNNING.

Состояние объекта Worker, которое завершается успешно, является SUCCEEDED, а свойство value установлено как результат этого объекта Worker.

В противном случае, если во время выполнения объекта Worker выбрасываются какие-либо исключения, его состояние становится FAILED, а для свойства исключения устанавливается тип произошедшего исключения.

В любое время, до завершения объекта Worker разработчик может прервать его, вызвав метод cancel, который помещает объект Worker в состояние CANCELED.

Прогресс работы, выполняемый объектом Worker, может быть получен с помощью трех различных свойств, таких как totalWork, workDone и progress.

Абстрактный класс Task расширяет класс java.util.concurrent. FutureTask, и конкретные реализации абстрактного класса Task должны переопределять его метод call, вызываемый средой выполнения в фоновом потоке.

Результатом выполнения задачи Task в фоновом потоке является объект V, возвращаемый методом call.

Результат выполнения фоновой задачи может быть получен с помощью метода getValue класса Task.

В методе call разрешено вызывать только методы updateProgress, updateMessage и updateTitle класса Task, обновляющие текущее количественное выполнение задачи, максимальное количественное выполнение задачи, текущее процентное выполнение задачи, сообщение, связанное с текущим состоянием выполнения задачи, и заголовок данной задачи.

В то время как метод call выполняется в фоновом потоке, методы updateProgress, updateMessage и updateTitle класса Task выполняются в потоке JavaFX Application Thread.

Поэтому, переопределяя данные методы в конкретной реализации абстрактного класса Task и обеспечивая их вызов в методе call, можно передавать значения свойств workDone, totalWork, progress, message и title из фонового потока в поток JavaFX Application Thread.

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

Так как класс Task расширяет класс FutureTask, то запуск его экземпляра может быть осуществлен с помощью объекта java.lang.Thread.

Запуск объекта Task также может быть произведен с помощью программного интерфейса Java Executor API.

В этом случае необходимо создать объект java.util.concurrent. ExecutorService с помощью класса-фабрики java.util.concurrent. Executors и воспользоваться методом submit интерфейса ExecutorService для запуска объекта Task.

Для завершения работы объекта ExecutorService нужно применить метод shutdown интерфейса ExecutorService.

Помимо перечисленных выше способов, создание и запуск объекта Task обеспечивает сервисный класс Service пакета concurrent.

Абстрактный класс Service также необходимо расширять конкретной реализацией с переопределением его метода createTask, возвращающего объект Task.

Запуск объекта Service осуществляется с помощью метода start,

перезапуск объекта Service – с помощью метода restart,

а сброс объекта Service – с помощью метода reset.

Прерывание выполнения фоновой задачи обеспечивает метод cancel класса Service.

Получить результат выполнения фоновой задачи можно с помощью метода getValue класса Service.

В качестве примера выполнения фоновой задачи в JavaFX-приложении здесь приведен код, в котором индикатор ProgressBar отображает ход вычислений, производимых в фоновом потоке.

Здесь мы создаем индикатор и кнопку.

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

В методе updateProgress мы обновляем индикатор.

Дальше мы запускаем задачу с помощью объекта Service.

И создаем вторую кнопку для сброса индикатора.

Если возникает потребность обновлять JavaFX компоненты в методе call задачи Task, можно использовать метод Platform.runLater с объектом Runnable, в методе run которого обращаться к JavaFX компонентам.

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

При создании объект ScheduledService находится в состоянии READY.

После вызова метода start или restart объект ScheduledService переходит в состояние SCHEDULED на время, указанное свойством delay.

В состоянии RUNNING объект ScheduledService выполняет свою задачу.

По завершении задачи объект ScheduledService переходит в состояние SUCCEEDED, затем в состояние READY, а затем возвращается в состояние SCHEDULED.

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

Если предыдущее выполнение завершено до истечения значения свойства period, то объект ScheduledService остается в состоянии SCHEDULED до истечения значения свойства period.

В противном случае, если предыдущее выполнение заняло больше времени, чем указанное значения свойства period, объект ScheduledService мгновенно переходит в состояние RUNNING.

В случае, когда задача завершается в состоянии FAILED, объект ScheduledService перезапускается или завершается, в зависимости от значений свойств restartOnFailure, backoffStrategy и maximumFailureCount.

Если свойство restartOnFailure имеет значение false, объект ScheduledService переходит в состояние FAILED и завершает работу.

В этом случае вы можете перезапустить поврежденный объект ScheduledService вручную.

Если свойство restartOnFailure имеет значение true, объект ScheduledService переходит в состояние SCHEDULED и остается в этом состоянии на протяжении всего свойства cumulativePeriod, которое получается в результате вызова свойства backoffStrategy.

Используя свойство cumulativePeriod, вы можете заставить поврежденный объект ScheduledService ждать до следующего прогона.

После успешного завершения ScheduledService свойство cumulativePeriod сбрасывается до значения свойства period.

Когда количество последовательных сбоев достигает значения свойства maximumFailureCount, объект ScheduledService переходит в состояние FAILED и завершает работу.

Любые изменения, которые происходят с свойствами delay и period при запуске объекта ScheduledService, будут учтены на следующей итерации.

Значения по умолчанию для свойств delay и period установлены в 0.

Совместное использование Swing и JavaFX, SWT и JavaFX

Пакет embed. swing платформы JavaFX обеспечивает встраивание JavaFX-сцены в Swing-приложение.

Для этого пакет javafx. embed. swing предоставляет компонент JFXPanel.

Класс JFXPanel расширяет класс swing. JComponent, являющийся базовым классом для всех Swing-компонентов, помещаемых в Swing-контейнеры верхнего уровня JFrame и JDialog.

Класс JFXPanel имеет, помимо унаследованных от класса JComponent, публичные методы, в том числе метод setScene, устанавливающий JavaFX сцену.

При использовании компонента JFXPanel в Swing-приложении необходимо учитывать, что Swing-компоненты обрабатываются в потоке Event Dispatch Thread, а JavaFX-компоненты – в потоке JavaFX Application Thread.

Поэтому для инициализации и изменения графа JavaFX-сцены в Swing-приложении используется метод Platform.runLater.

А для инициализации и изменения Swing-интерфейса используется метод SwingUtilities.invokeLater.

Обратную операцию – встраивание Swing компонентов в JavaFX приложение позволяет класс SwingNode пакета embed. swing.

Здесь мы создаем некий Swing контент, который устанавливаем в узел SwingNode методом setContent.

Делаем мы это в Swing потоке Event Dispatch Thread.

И затем используем этот узел уже в потоке JavaFX Application Thread.

Аналогично пакету embed. swing, пакет embed. swt платформы JavaFX обеспечивает встраивание JavaFX-сцены в SWT-приложение.

Для этого пакет embed. swt предоставляет компонент FXCanvas.

Класс FXCanvas расширяет класс Canvas пакета swt. widgets графической библиотеки SWT, обеспечивающий рисование произвольной графики.

Класс FXCanvas имеет, помимо унаследованных от класса Canvas, публичные методы, в том числе метод setScene, устанавливающий JavaFX сцену.

JavaFX-сцена вставляется в FXCanvas-компонент, а FXCanvas-компонент вставляется в SWT-окно Shell с помощью приведенного здесь шаблона кода.

О библиотеке SWT мы поговорим позже.

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

Использование языка FXML заключается в создании FXML-файла, содержащего описание дочерних узлов корневого узла графа сцены, и загрузки его с помощью статического метода load класса FXMLLoader, возвращающего корневой узел графа сцены.

Преимущество такой модели создания графического интерфейса заключается в том, что изменение графа сцены JavaFX-приложения не требует перекомпиляции Java-кода – FXML-описание интерфейса загружается при запуске JavaFX-приложения.

FXML-файл содержит описание корневой JavaFX-панели AnchorPane с дочерними JavaFX-компонентами Button и Label.

Атрибут onAction компонента Button ссылается на метод handleButtonAction, обрабатывающий нажатие кнопки Button, класса Controller, который определен в качестве контроллера атрибутом fx: controller компонента AnchorPane.

Язык FXML поддерживает шаблон проектирования Model-View-Controller (MVC), разделяющий бизнес-логику, представление данных и взаимодействие с пользователем.

В MVC-терминологии FXML-описание является представлением View, модель Model представляет компонент JavaFX Beans, обеспечивающий данные JavaFX-приложения, а контроллером Controller является Java-класс, реализующий код взаимодействия с пользователем и связывания компонента JavaFX Beans с FXML-описанием графического интерфейса JavaFX-приложения.

Для включения такого контроллера в JavaFX-приложение, его необходимо указать в качестве значения атрибута fx: controller FXML-описания.

FXML-контроллер может реализовывать интерфейс Initializable, имеющий единственный метод initialize, вызываемый средой выполнения для инициализации класса FXML-контроллера и используемый, например, для связывания компонента данных JavaFX Beans с FXML-описанием.

Методу initialize, в качестве аргументов, среда выполнения передает URL-адрес FXML-описания графического интерфейса JavaFX-приложения и ResourceBundle-ресурсы JavaFX-приложения.

URL-адрес FXML-описания и ResourceBundle-ресурсы определяются при вызове в главном классе JavaFX-приложения статического метода load класса FXMLLoader.

Файл ResourceBundle-ресурсов решает задачу локализации строк графического интерфейса и передается как ResourceBundle-объект методу load с помощью статического метода getBundle класса java.util.ResourceBundle.

В пакете приложения можно создать файл с расширением. properties, имя которого без расширения, но предваряя именем пакета, нужно указать в аргументе метода ResourceBundle.getBundle.

Заполнив файл ResourceBundle-ресурсов парами ключ-значение, получить доступ к любому значению можно с помощью метода getString класса ResourceBundle в Java-коде, указав в качестве аргумента ключ, или используя префикс «%» и имя ключа в качестве значения атрибута компонента FXML-описания.

Помимо интерфейса Initializable, FXML-контроллер может использовать аннотацию @FXML пакета javafx. fxml, которая маркирует protected или private поля и методы FXML-контроллера, доступные из FXML-описания.

Чтобы не применять аннотацию @FXML, поля и методы FXML-контроллера, доступные из FXML-описания, делаются публичными.

FXML-описание графического интерфейса JavaFX-приложения имеет структуру XML-документа, однако не имеет конкретной XML-схемы.

Для использования специфических XML-элементов пространства имен языка FXML, в FXML-описание должно быть включено объявление пространства имен xmlns: fx.

Экземпляр JavaFX-компонента создается в FXML-описании с помощью тэга импорта и тэга, начинающегося с имени класса JavaFX-компонента.

FXML-описание позволяет создавать не только экземпляры JavaFX-компонентов, но и другие Java-объекты.

Экземпляр хэш-таблицы java. util. HashMap создается с помощью соответствующего тэга.

Экземпляр Java-класса, имеющего статический метод valueOf создается, используя атрибут fx: value.

Java-объект, возвращаемый методом класса-фабрики, создается, используя атрибут fx: factory.

Кроме того, для создания экземпляров классов можно переопределить фабрику JavaFXBuilderFactory, используемую по умолчанию для создания JavaFX-объектов.

Для этого при вызове в главном классе JavaFX-приложения статического метода load класса FXMLLoader необходимо в качестве аргумента указать экземпляр пользовательского класса, реализующего интерфейс BuilderFactory.

Интерфейс BuilderFactory имеет единственный метод getBuilder, возвращающий экземпляр класса, который реализует интерфейс Builder.

Поэтому необходимо также создать пользовательский класс, реализующий интерфейс Builder.

Интерфейс Builder имеет единственный метод build, возвращающий Java-объект.

Теперь, другие теги языка FXML, такие как <fx: include> и <fx: reference>.

Тэг <fx: include> языка FXML обеспечивает модульность FXML-описания и указывает своим атрибутом source имя включаемого FXML-файла, содержащего описание создаваемых JavaFX-компонентов.

Тэг <fx: reference> языка FXML своим атрибутом source позволяет сослаться на другой именованный FXML-элемент.

Атрибуты FXML-элементов могут быть нескольких типов.

Атрибут FXML-элемента может описывать свойство JavaFX-компонента.

Как альтернатива FXML-атрибуту, свойство JavaFX-компонента может описывать вложенный тэг FXML-элемента.

Атрибуты FXML-элемента, описывающие JavaFX-свойства, могут использовать различные префиксы.

Здесь тэг <fx: define> языка FXML позволяет создавать объекты, на которые можно ссылаться из любого уровня графа сцены.

Атрибут FXML-элемента может описывать статические свойства класса, при этом атрибут имеет вид:

[имя класса]. [имя свойства] =” [значение]»

Атрибут FXML-элемента также может описывать обработчик событий JavaFX-компонента.

Здесь тэг <fx: script> языка FXML обеспечивает включение в FXML-описание кода JVM-языков, таких как JavaScript, Groovy и другие.

Скриптовый код может быть включен непосредственно в тэг <fx: script>, или может содержаться в отдельном файле, который включается в FXML-описание атрибутом source тэга <fx: script>.

Визуальный графический редактор JavaFX Scene Builder существенно упрощает создание FXML-описания графического интерфейса.

Дистрибутив редактора Scene Builder доступен для скачивания по указанному адресу.

После установки, редактор Scene Builder запускается с помощью файла bin/scenebuilder. exe, который открывает главное окно, состоящее из набора панелей Library, Hierarchy, рабочей области и панелей свойств, компоновки и событий графических компонентов.

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

Графическая система SWT (Standard Widget Toolkit) была создана в процессе работы над проектом Eclipse и является попыткой взять лучшее из архитектур систем AWT и Swing и предоставить возможность создания быстрых интерфейсов с отображением Look and Feel, как можно более полно соответствующим операционной системе, в которой они работают.

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

Для операционной системы, в которой отсутствует реализация какого-либо компонента, система SWT обеспечивает Java-эмуляцию.

Так в системе SWT достигается скорость работы и полное соответствие внешнему виду и поведению операционной системы.

Для создания интерфейса пользователя система SWT предоставляет такие компоненты как кнопки, включая флажки и переключатели, списки, метку, меню, текстовые области, диалоговые окна, индикатор прогресса, панель с прокруткой, слайдер и спиннер, таблицы и деревья, панель с вкладками, панель выбора даты, панели инструментов, встроенный Web-браузер, гиперссылку, а также обеспечивает компоновку SWT-компонентов, встраивание AWT-компонентов, отображение OpenGL-контента, печать, поддержку операций Drag and Drop, 2D-графики, технологии Win32 OLE.

Система JFace создана на основе системы SWT и реализует архитектуру MVC (Model-View-Controller), предоставляя такие компоненты как таблицы, деревья, списки, текстовую область и диалоговые окна, обеспечивая определение пользовательских команд независимо от их представления в интерфейсе пользователя, управление шрифтами и изображениями, помощь пользователю в выборе соответствующего содержания для полей в компонентах, выполнение длительных задач.

Мы рассмотрим создание SWT/JFace приложений с помощью инструментов Eclipse-плагина WindowBuilder.

Плагин WindowBuilder обеспечивает шаблоны кода для создания Java-приложений с интерфейсом пользователя на основе библиотек Swing, SWT/JFace, RCP и XWT, предоставляя визуальный графический редактор и большой набор Wizard-мастеров.

Для установки WindowBuilder-плагина откроем среду Eclipse, в меню Help выберем Install New Software.

В окне мастера Install в поле Work with: выберем Eclipse-релиз и в разделе General Purpose Tools отметим соответствующие флажки.

Нажмем кнопку Next и установим плагины.

После установки WindowBuilder-плагина перезагрузим среду Eclipse и в перспективе Java в меню File выберем команду New | Other | WindowBuilder | SWT Designer | SWT/JFace Java Project и нажмем кнопку Next.

Введем имя проекта и нажмем кнопку Finish.

В результате будет создан Java-проект, в путь которого будут добавлены библиотеки, обеспечивающие использование библиотек SWT и JFace.

В окне Project Explorer нажмем правой кнопкой мышки на узле проекта и в контекстном меню выберем команду New | Other | WindowBuilder | SWT Designer.

Здесь раздел SWT содержит следующие мастера:

Application Window – создает основу приложения с интерфейсом, содержащим главное окно с заголовком и кнопками «свернуть», «развернуть» и «закрыть».

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

Dialog – создает класс, расширяющий класс Dialog, который является базовым классом для SWT-диалоговых окон. Созданный класс представляет диалоговое окно с заголовком и кнопкой закрытия окна.

Shell – создает основу приложения с интерфейсом, содержащим главное окно с заголовком и кнопками «свернуть», «развернуть» и «закрыть», путем создания класса, расширяющего класс Shell. По сравнению с мастером Application Window данный мастер выделяет из метода main код определения свойств Shell-окна.

Раздел JFace содержит следующие мастера:

ApplicationWindow – создает основу приложения с интерфейсом, содержащим главное окно с заголовком и кнопками «свернуть», «развернуть» и «закрыть», путем создания класса, расширяющего класс ApplicationWindow, который также позволяет определить для окна – меню, панель инструментов и строку статуса. При этом панель инструментов может представлять класс ToolBar или класс CoolBar. Объект ToolBar представляет в JFace-приложении набор JFace-действий, а объект CoolBar – набор ToolBar-панелей.

Dialog – создает класс, расширяющий класс Dialog, который является базовым классом для JFace-диалоговых окон. Созданный класс представляет диалоговое окно с кнопкой закрытия окна и кнопками OK и Cancel.

TitleAreaDialog – создает класс, расширяющий класс TitleAreaDialog, который представляет диалоговое окно с кнопкой закрытия окна и кнопками OK и Cancel, а также областью заголовка.

Wizard – создает класс, расширяющий класс Wizard, который является базовым классом для создания мастеров.

WizardPage – создает класс, расширяющий класс WizardPage, который является базовым классом для создания страниц мастеров. Созданный класс представляет страницу мастера с заголовком и кнопками Finish и Cancel.

Мастер – это то что показано на слайде – wizard.

Раздел Forms содержит следующие мастера:

Composite – создает класс, расширяющий класс Composite. По сравнению с мастером Composite раздела SWT данный мастер добавляет использование класса FormToolkit, который отвечает за адаптацию SWT-компонентов для работы в формах.

DetailsPage – создает класс, реализующий интерфейс IDetailsPage, который обеспечивает создание страниц детализации, открываемых при выборе объекта в основной части формы.

FormPage – создает класс, расширяющий класс FormPage, который является базовым классом для создания страниц многостраничной формы FormEditor.

MasterDetailsBlock – создает класс, расширяющий класс MasterDetailsBlock, который обеспечивает создание блока формы, состоящего из основной части и части детализации, отображающей IDetailsPage-страницы.

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

ViewPart – создает класс, расширяющий класс ViewPart, который является базовым классом для создания Eclipse-представлений.

Раздел Databinding содержит мастер JFace Automating Databinding, обеспечивающий создание Shell-окна, Composite-контейнера и Dialog-окна, включающих в себя текстовые поля, содержимое которых связано со свойствами JavaBeans-компонента.

Раздел RCP содержит следующие мастера:

RCP – это Rich Client Platform ограниченный набор плагинов Eclipse-платформы для создания настольного приложения с графическим интерфейсом пользователя.

В этом смысле среда выполнения Eclipse является RCP-приложением.

Итак, здесь ActionBarAdvisor – создает класс, расширяющий класс ActionBarAdvisor, который обеспечивает конфигурацию меню и панели инструментов Workbench-окна RCP-приложения.

EditorPart – создает класс, расширяющий класс EditorPart, который является базовым классом для создания Eclipse-редакторов Workbench-окна RCP-приложения.

MultiPageEditorPart – создает класс, расширяющий класс MultiPageEditorPart, который является базовым классом для создания многостраничных Eclipse-редакторов Workbench-окна RCP-приложения.

PageBookViewPage – создает класс, расширяющий класс org.eclipse.ui.part.Page, который является базовым классом для создания страниц многостраничного Eclipse-представления PageBookView.

Perspective – создает класс, реализующий интерфейс IPerspectiveFactory, который обеспечивает группировку представлений и редакторов Workbench-окна RCP-приложения.

PreferencePage – создает класс, расширяющий класс PreferencePage, который является базовым классом для создания окна команды Preferences меню Window.

PropertyPage – создает класс, расширяющий класс PropertyPage, который является базовым классом для создания окна команды Properties меню Project.

ViewPart – создает класс, расширяющий класс ViewPart, который является базовым классом для создания Eclipse-представлений. По сравнению с мастером ViewPart Forms данный мастер не использует класс FormToolkit.

Раздел XWT команды New содержит следующие мастера:

XWT Application – создает основу XWT-приложения с интерфейсом, содержащим главное окно с заголовком и кнопками «свернуть», «развернуть», «закрыть» и Double click me!.

XWT Composite – создает XWT-класс, расширяющий класс Composite, который представляет контейнер для других XWT-компонентов.

XWT Forms Application – создает основу XWT-приложения с GUI-интерфейсом, содержащим главное окно формы с заголовком и кнопками «свернуть», «развернуть», «закрыть» и Double click me!.

XWT Forms Composite – создает XWT-класс формы, расширяющий класс Composite.

Раздел Eclipse 4 команды New содержит мастер ViewPart, использующий аннотацию Focus, которая маркирует метод класса представления, вызываемый при наведении фокуса.

Общие настройки WindowBuilder-плагина осуществляются в разделе WindowBuilder команды Preferences меню Window среды Eclipse.

SWT-приложения

Для создания SWT-приложения в окне Package Explorer нажмем правой кнопкой мышки на узле проекта, созданного с использованием мастера SWT/JFace Java Project, и в контекстном меню выберем команду New | Other | WindowBuilder | SWT Designer | SWT | Shell, нажмем кнопку Next, введем имя пакета и имя класса и нажмем кнопку Finish.

В результате будет создан главный класс SWT-приложения, расширяющий класс Shell и имеющий публичный конструктор, защищенный метод createContents, статический метод main и защищенный метод checkSubclass.

Класс Shell представляет окно с заголовком и кнопками «свернуть», «развернуть» и «закрыть».

Публичный конструктор главного класса SWT-приложения переопределяет конструктор класса Shell, где display – экземпляр класса Display.

Система SWT представляет собой Java-оболочку библиотеки графических компонентов низлежащей операционной системы.

При создании экземпляра SWT-компонента создается соответствующий компонент операционной системы, и, наоборот, при удалении экземпляра SWT-компонента, соответствующий компонент операционной системы также удаляется.

В этой архитектуре Display-объект представляет низлежащую операционную систему, обеспечивая связь между системой SWT и операционной системой.

Перед созданием какого-либо экземпляра SWT-компонента необходимо создать Display-объект, при этом для каждого SWT-приложения может существовать только один Display-объект.

При создании Display-объекта создается специальный поток, или правильнее сказать Display-объект создается в специальном потоке, называемом UI-потоком (user-interface thread), который отвечает за выполнения цикла событий и вызов большинства методов программного интерфейса SWT API.

Класс Display предоставляет программный интерфейс для регистрации и удаления слушателей событий низлежащей операционной системы, взаимодействия с другими потоками, доступа к системным ресурсам (цвет, курсор, шрифт и др.) и так далее.

В конструкторе класса SWT-приложения вызывается суперконструктор класса Shell.

Так как система SWT представляет собой Java-оболочку библиотеки GUI-компонентов низлежащей операционной системы, а компоненты операционной системы имеют свои характеристики (styles), система SWT также определяет для своих компонентов характеристики или стили.

SWT-стили компонентов хранятся в специальном классе SWT.

Подходящие для Shell-окна стили – это константы SHELL_TRIM (окно с заголовком и кнопками закрытия и сворачивания, разворачивания) и DIALOG_TRIM (окно с заголовком и кнопкой закрытия), а также константы, определяющие модальность окна APPLICATION_MODAL, MODELESS, PRIMARY_MODAL и SYSTEM_MODAL.

После вызова суперконструктора, в конструкторе класса SWT-приложения вызывается метод createContents, предназначенный для определения свойств Shell-окна.

Защищенный метод createContents главного класса SWT-приложения отвечает за определение свойств окна SWT-приложения.

В методе createContents устанавливается текст заголовка окна и размеры окна.

Статический метод main главного класса SWT-приложения является точкой входа в приложение.

В методе main в первую очередь создается Display-объект, используя статический метод getDefault, затем с помощью конструктора создается экземпляр главного класса приложения, помним, что при этом в методе createContents определяются свойства окна приложения.

Далее окно открывается методом open класса Shell и производится компоновка содержимого окна методом layout класса Composite (суперкласса класса Shell).

После этого в методе main организуется цикл, который прекращается при закрытии окна (!shell.isDisposed ()) и в котором UI-поток засыпает, используя метод sleep класса Display, до тех пор, пока в очереди событий не появится какое-либо событие (!display.readAndDispatch ()).

Защищенный метод checkSubclass главного класса SWT-приложения переопределяет метод суперкласса Decorations.

Система SWT позволяет расширять свои классы только в определенных узлах иерархии программного интерфейса API, таких как классы Composite и Canvas.

Метод checkSubclass контролирует это правило до тех пор, пока он не будет переопределен, поэтому в данном случае главный класс SWT-приложения вынужден переопределить этот метод, так как он расширяет класс Shell, который не предназначен для расширения.

Откроем созданный главный класс SWT-приложения в Eclipse-редакторе плагина WindowBuilder. При этом редактор будет иметь три вкладки:

Source – редактирование исходного кода.

Design – визуальный графический редактор GUI-интерфейса.

Bindings – создание и редактирование связывания данных.

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

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

Данная область имеет контекстное меню, позволяющее:

Вырезать, копировать, вставлять и удалять компоненты (команды Cut, Copy, Paste, Delete),

Предварительно посмотреть конечный вид интерфейса без запуска приложения (команда Test/Preview),

Обновить область (команда Refresh),

Добавить в компонент слушателя событий (команда Add event handler),

Установить компоновку дочерних компонентов (команда Set layout),

Установить минимальные размеры компонента (команда Set minimal size),

Удалить метод setSize (команда Remove setSize ()),

Определить SWT-стиль (команда Style),

Создать связывание данных для выбранного компонента (команда Bindings),

Определить родительский контейнер для выбранного компонента (команда Surround with),

Изменить порядок дочерних компонентов в списке (команда Order),

Подогнать размеры компонента (команда Autosize control),

Выбрать компоненты (команда Select),

Создать метод, возвращающий экземпляр компонента (команда Expose component),

Превратить в другой компонент (команда Morph),

Создать класс-фабрику для выбранного компонента (команда Factory),

Переименовать компонент (команда Rename).

Окно Structure имеет контекстное меню с аналогичной функциональностью.

Палитра компонентов Palette содержит следующие разделы:

System – инструменты выбора элементов: Selection (выбор элемента с помощью курсора), Choose Component (выбор элемента с помощью мастера Open type), Marquee (выбор группы элементов), Tab Order (определение порядка выбора элементов пользователем с помощью клавиши Tab).

Composites – контейнеры пакетов org.eclipse. swt. widgets и org.eclipse.swt.custom.

Layouts – компоновки пакетов org.eclipse.swt.layout, org.eclipse.swt.custom и swing2swt.layout.

Controls – SWT-компоненты пакетов org.eclipse. swt. widgets, org.eclipse.swt.custom и org.eclipse.swt.browser.

JFace – JFace-компоненты пакетов org.eclipse.jface.viewers, org.eclipse. jface. text и org.eclipse.jface.fieldassist.

Forms API – формы и компоновки пакета org.eclipse.ui.forms. widgets.

Menu – меню пакета org.eclipse. swt. widgets.

SWT_AWT – мост между системами SWT и AWT, представленный классом SWT_AWT, и набор AWT/Swing компонентов для встраивания в SWT-приложение.

Добавление компонентов из Palette-палитры в область визуального редактирования осуществляется нажатием соответствующего компонента в окне палитры и наведении курсора мышки на требуемую позицию компонента в области визуального редактирования.

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

При добавлении компонента в Shell-окно SWT-приложения, его исходный код добавляется в конструкторе класса между вызовами суперконструктора и метода createContents.

Добавлять компоненты из Palette-палитры можно также нажав соответствующий компонент в окне палитры, наведя курсор мышки на желаемый родительский компонент в окне Structure и щелкнув левой кнопкой мышки.

Окно Palette-палитры имеет контекстное меню, обеспечивающее добавление раздела и компонента в палитру, добавление класса-фабрики, импорт JAR-файла компонента, редактирование элемента палитры, удаление компонента из палитры, восстановление палитры по умолчанию, открытие мастера Palette Manager, импорт и экспорт палитры в XML-формате, общие настройки палитры.

Palette-палитру можно открыть в отдельном представлении с помощью выбора команды Show View | Other | WindowBuilder | Palette меню Window.

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

Контейнеры раздела Composites Palette-палитры предназначены для объединения группы компонентов с применением к ним общей компоновки.

Базовым классом контейнеров раздела Composites Palette-палитры является класс Composite, который сам может служить контейнером для компонентов.

Раздел Composites Palette-палитры также содержит такие контейнеры как CBanner, CTabFolder, Group, SashForm, ScrolledComposite, TabFolder и ViewForm.

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

Установить цвет фона, а также другие свойства Composite-компонента, такие как имя экземпляра класса, стиль, размеры, компоновку, связывание свойств, включение и выключение, шрифт, цвет переднего плана, порядок табуляции и текст подсказки можно в окне Properties вкладки Design.

Контейнер Group отличается от контейнера Composite отображением своих границ и возможностью определения заголовка.

Контейнер ScrolledComposite отображает свои границы и обеспечивает полосы прокрутки.

Контейнер SashForm группирует свои дочерние элементы в строки или столбцы, разделяя их полосой Sash.

Контейнер TabFolder представляет панель с вкладками, где вкладки представлены классом TabItem. Для вкладки TabItem можно определить заголовок и значок.

Контейнер CTabFolder также представляет панель с вкладками, где вкладки представлены классом CTabItem.

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

Вкладка CTabItem отличается от вкладки TabItem тем, что вкладку CTabItem можно обеспечить кнопкой «закрыть».

Контейнер ViewForm отличается от контейнера Composite возможностью регулировки отступов, видимости границ и размещения компонентов в верхней части по центру, справа и слева.

Контейнер ViewForm используется в Workbench-окне для компоновки метки, меню и панели инструментов представления.

Контейнер CBanner делит свое содержимое на три части – справа, слева и низ, в которых можно размещать компоненты.

Компоновки раздела Layouts Palette-палитры обеспечивают компоновку дочерних компонентов контейнера различным способом.

Определить компоновку для контейнера во вкладке Design WindowBuilder-редактора можно либо с помощью команды Set layout контекстного меню области визуального редактирования, либо в поле Layout окна Properties.

Базовым классом компоновок раздела Layouts служит класс Layout.

Раздел Layouts Palette-палитры предоставляет такие компоновки как Absolute layout, FillLayout, GridLayout, FormLayout, RowLayout, StackLayout, FlowLayout, BoxLayout, BorderLayout.

Компоновка Absolute layout – это нулевая компоновка setLayout (null), в которой координаты дочерних компонентов определяются аргументами метода setBounds суперкласса Control.

Компоновка FillLayout размещает компоненты в строку или столбец, подгоняя их к одному размеру, и имеет регулировки отступов и типа (горизонтальный или вертикальный).

Компоновка GridLayout представляет сетку ячеек для компоновки компонентов и имеет регулировки отступов и числа столбцов ячеек.

Размеры компонента, его выравнивание, а также количество ячеек строки и столбца, которые занимает компонент, могут быть установлены путем вызова метода setLayoutData суперкласса Control с аргументом – объектом GridData.

Компоновка FormLayout размещает компоненты с помощью создания якорей.

Размещение дочерних компонентов с использованием компоновки FormLayout осуществляется выполнением следующих шагов:

С помощью конструктора создается экземпляр класса FormData.

Класс FormData имеет поля bottom, left, right, top, определяющие прикрепление четырех сторон компонента, а также поля height и width, определяющие предпочтительные размеры компонента.

Определяются значения полей экземпляра класса FormData путем присваивания экземпляров класса FormAttachment.

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

Экземпляр класса FormData связывается с компонентом с помощью метода setLayoutData суперкласса Control.

Компоновка RowLayout размещает компоненты в строку или столбец и имеет регулировки отступов, выравнивания и типа (горизонтальный или вертикальный).

В отличие от компоновки FillLayout для компоновки RowLayout можно установить перенос на следующую строку или столбец, а размеры компонента могут быть определены путем вызова метода setLayoutData суперкласса Control с аргументом – объектом RowData.

Экземпляр класса RowData создается с помощью конструктора.

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

При этом поле topControl определяет, какой компонент находится на вершине стека.

Компоновка FlowLayout представляет собой перенос AWT-компоновки FlowLayout в систему SWT.

Компоновка FlowLayout располагает компоненты аналогично строкам текста в параграфе и имеет регулировки выравнивания и отступов.

Компоновка BoxLayout представляет собой перенос Swing-компоновки BoxLayout в систему SWT.

Компоновка BoxLayout располагает компоненты по оси X или по оси Y в одну строку или столбец без возможности переноса.

Компоновка BorderLayout представляет собой перенос AWT-компоновки BorderLayout в систему SWT.

Компоновка BorderLayout делит контейнер на пять областей – север, юг, восток, запад и центр, в которых и располагает компоненты.

Раздел Controls Palette-палитры предоставляет SWT-компоненты пакетов org.eclipse. swt. widgets, org.eclipse.swt.custom и org.eclipse.swt.browser.

Кроме того, раздел Controls Palette-палитры обеспечивает определение с помощью пакета org.eclipse. swt. dnd источника и цели операции Drag and Drop.

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

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

Так как система SWT представляет собой Java-оболочку библиотеки графических компонентов низлежащей операционной системы, а многие библиотеки интерфейса требуют определения родителя при создании компонента, который, кроме того, имеет свои характеристики (styles), система SWT также определяет создание компонента с помощью конструктора класса, аргументами которого служат – объект родительского компонента и стиль создаваемого компонента, описывающий его поведение и внешний вид.

В этом состоит отличие системы SWT от систем AWT и Swing, в которых дочерние компоненты добавляются к компоненту-контейнеру с помощью метода add.

Удаление экземпляров компонентов системы SWT также имеет свою особенность.

Так как при создании экземпляра SWT-компонента создается соответствующий экземпляр компонента операционной системы, а сборщик мусора JVM не имеет четкого расписания времени, для корректного управления ресурсами необходимо программным способом удалять экземпляры SWT-компонентов, используя метод dispose.

Для обработки событий компонентов система SWT предлагает два типа слушателей – типизированные и не типизированные слушатели.

Не типизированные слушатели присоединяются к SWT-компоненту методом addListener класса Widget, где параметр eventType – код типа события, определяемый полем класса SWT, а параметр listener – экземпляр класса (как правило, анонимного), реализующего интерфейс Listener с единственным методом handleEvent.

Типизированные слушатели присоединяются к SWT-компоненту методами addХХХListener, где параметр listener – экземпляр класса (как правило, анонимного), реализующего интерфейс ХХХListener с методами обработки конкретного типа событий.

Раздел JFace Palette-палитры обеспечивает использование JFace-компонентов пакетов org.eclipse.jface.viewers, org.eclipse. jface. text и org.eclipse.jface.fieldassist.

JFace-компоненты ComboViewer, ListViewer, TableViewer, TableViewerColumn, CheckboxTableViewer, TreeViewer, TreeViewerColumn, CheckboxTreeViewer и TextViewer представляют собой обертки соответствующих SWT-компонентов, реализуя архитектуру MVC.

При добавлении JFace-компонентов в область визуального редактирования WindowBuilder-редактора отображается SWT-компонент и значок JFace-компонента.

Реализация архитектуры MVC JFace-компонентами заключается в том, что данные и метки компонента определяются отдельно с помощью объектов IContentProvider и IBaseLabelProvider, которые устанавливаются для JFace-компонента методами setContentProvider и setLabelProvider соответственно.

Расширения интерфейса IContentProvider обеспечивают возврат данных для JFace-компонентов. Для дерева – это интерфейс ITreeContentProvider, для списка и таблицы – это интерфейс IStructuredContentProvider.

Расширения интерфейса IBaseLabelProvider обеспечивают возврат меток для элементов JFace-компонентов. Для дерева и списка – это интерфейс ILabelProvider, для таблицы – это интерфейс ITableLabelProvider.

После создания поставщика данных и присоединения его к JFace-компоненту необходимо вызвать метод setInput для загрузки данных.

Кроме того, для вышеуказанных JFace-компонентов с помощью метода setSorter можно определить сортировку, которая обеспечивается объектом ViewerSorter, а с помощью метода setFilters определить фильтрацию, обеспечиваемую объектами ViewerFilter.

JFace-компонент TextViewer также представляет собой обертку SWT-компонента StyledText, реализующую архитектуру MVC.

Реализация архитектуры MVC компонентом TextViewer заключается в том, что документ, т.е. данные для редактирования определяются отдельно с помощью объекта Document, который связывается с TextViewer-компонентом методом setDocument.

Библиотеки org.eclipse. jface. text.* системы JFace позволяют создать на основе компонента TextViewer полнофункциональный редактор, обеспечивающий подсветку текста, форматирование, автодополнение текста, отмену изменений, поиск и замену и так далее.

Раздел Forms API Palette-палитры обеспечивает использование пакета org.eclipse.ui.forms. widgets.

Eclipse-формы представляют способ организации SWT/JFace компонентов таким образом, что конечный интерфейс имеет сходство с Web-страницей.

Такой эффект достигается без использования встроенного Web-браузера за счет применения специального класса FormToolkit для адаптации компонентов к работе в форме, компоновки TableWrapLayout, работающей аналогично HTML-таблице, набора специальных контейнеров и компонентов пакетов org.eclipse.ui.forms. widgets и org.eclipse.ui.forms, а также многостраничного редактора FormEditor.

Раздел Menu Palette-палитры обеспечивает использование различного рода меню пакета org.eclipse. swt. widgets.

И наконец элемент SWT_AWT Composite раздела SWT_AWT Palette-палитры при перетаскивании в область визуального редактирования инициирует генерацию следующего кода.

В данном коде создается SWT-контейнер Composite, с которым связывается AWT-окно Frame с помощью метода new_Frame класса SWT_AWT, служащего мостом между системами SWT и AWT.

Далее окно Frame подготавливается для присоединения AWT и Swing компонентов путем определения для него корневой панели и компоновки.

Элемент Choose Swing Component раздела SWT_AWT Palette-палитры открывает палитру AWT и Swing компонентов для добавления их в окно Frame.

Связывание данных

Платформа Eclipse предоставляет программный интерфейс связывания данных, представленный библиотеками org.eclipse.core. databinding.* и org.eclipse. jface. databinding.*, которые обеспечивают связывание свойств Widget-компонентов и объектов данных.

Связывание данных (Data Binding) представляет собой синхронизацию двух источников данных таким образом, что изменение данных одного объекта автоматически отражается в другом объекте.

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

WindowBuilder-плагин обеспечивает связывание данных с помощью мастера JFace Automating Databinding раздела WindowBuilder | SWT Designer | Databinding команды New, команды Bindings контекстного меню визуальной области редактирования и окна Structure, а также с помощью вкладки Bindings WindowBuilder-редактора, которая имеет функциональность, аналогичную функциональности команды Bindings контекстного меню.

Для создания связывания данных с помощью мастера JFace Automating Databinding в окне Package Explorer перспективы Java среды Eclipse щелкнем правой кнопкой мышки на узле проекта, созданного с помощью мастера SWT/JFace Java Project, и в контекстном меню выберем команду New | Other | Java | Class и нажмем кнопку Next, введем имя пакета и имя класса и нажмем кнопку Finish.

В окне редактора исходного кода дополним код класса.

Теперь класс Data является JavaBeans-компонентом, представляющим данные приложения.

В окне Package Explorer щелкнем правой кнопкой мышки на узле класса Data и в контекстном меню выберем команду New | Other | WindowBuilder | SWT Designer | Databinding | JFace Automating Databinding и нажмем кнопку Next, в окне мастера выберем переключатель Shell и нажмем кнопку Next.

В поле Properties: выберем свойство data класса Data и нажмем кнопку Finish.

В результате будет создано окно Shell, включающее в себя текстовое поле, содержимое которого синхронизировано со свойством data класса Data.

Связывание данных данного SWT-приложения устанавливается с помощью создания объекта DataBindingContext, который отвечает за хранение информации обо всех связываниях данных приложения.

Связывание данных вносится в DataBindingContext-объект с помощью методов класса DataBindingContext:

Метод bindList – синхронизирует два списка java.util.List.

Метод bindSet – синхронизирует два набора java.util.Set.

Метод bindValue – синхронизирует два объекта.

В данном SWT-приложении применяется метод bindValue для синхронизации свойства Text-компонента со свойством JavaBeans-компонента.

При этом свойство Text-компонента и свойство JavaBeans-компонента обертываются в объекты IObservableValue, обеспечивающие отслеживание изменений значений свойств.

Обертывание свойства Text-компонента в IObservableValue-объект производится с помощью статического метода observeText класса-фабрики SWTObservables, а обертывание свойства JavaBeans-компонента – с помощью статического метода observeValue класса-фабрики PojoObservables.

В методе main данного SWT-приложения Shell-окно создается в специальном UI-потоке, для которого определен контекст доступа к IObservable-объектам, обеспечивающий уведомление IObservable-объектами своих слушателей.

Такой контекст представлен объектом Realm.

Для демонстрации связывания данных во вкладке Design WindowBuilder-редактора перенесем в Shell-окно элемент Button раздела Controls Palette-палитры и два раза щелкнем по нему мышкой – в результате будет сгенерирован код создания Button-компонента и присоединения к нему слушателя событий выбора компонента.

Дополним код обработчика событий компонента.

В выделенных строках кода изменяется значение свойства data объекта Data и вызывается метод, обновляющий DataBindingContext-контекст.

После запуска приложения выбором команды Run As | Java Application контекстного меню окна Package Explorer при нажатии кнопки окна приложения в текстовом поле появится значение свойства JavaBeans-компонента «Hello».

Для того чтобы в обработчике событий кнопки не обновлять DataBindingContext-контекст вызовом метода setData, изменим код класса Data и код метода initDataBindings.

Здесь мы добавляем слушателей свойства JavaBeans-компонента, и в его методе setData автоматически генерируем событие изменения значения свойства.

Здесь мы обертываем свойство JavaBeans-компонента.

Для создания связывания данных с помощью вкладки Bindings WindowBuilder-редактора во вкладке Design WindowBuilder-редактора перенесем в Shell-окно элемент Label раздела Controls Palette-палитры и перейдем на вкладку Bindings.

Во вкладке Bindings в поле Target выберем Label-компонент, в поле Properties – его свойство text. В поле Model кнопкой Widgets переключимся на компоненты и выберем Text-компонент, а в нижнем поле Properties – его свойство text и нажмем кнопку создания связывания.

В окне мастера Create Data Binding нажмем кнопку OK.

В результате метод initDataBindings дополнится кодом.

Здесь текст поля связывается с текстом Label-компонента.

Убедимся, что вызов метода initDataBindings производится после создания Label-компонента, и во вкладке Design WindowBuilder-редактора в области визуального редактирования нажмем на Label-компоненте правой кнопкой мышки и в контекстном меню выберем команду Horizontal alignment | Fill, гарантируя отображение текста метки.

Теперь после запуска приложения изменение текста в текстовом поле приведет к автоматическому изменению текста метки.

JFace-приложения

Для создания JFace-приложения

в окне Package Explorer нажмем правой кнопкой мышки на узле проекта, созданного с использованием мастера SWT/JFace Java Project, и в контекстном меню выберем команду New | Other | WindowBuilder | SWT Designer | JFace | ApplicationWindow, нажмем кнопку Next, введем имя пакета и имя класса и нажмем кнопку Finish.

В результате будет создан главный класс JFace-приложения, представляющий окно с заголовком и кнопками «свернуть», «развернуть» и «закрыть», расширяющий класс ApplicationWindow и имеющий публичный конструктор, статический метод main, внутренний метод createActions и переопределенные методы createContents, createMenuManager, createToolBarManager, createStatusLineManager, configureShell и getInitialSize.

В конструкторе главного класса JFace-приложения вызывается конструктор класса ApplicationWindow с аргументом Shell null, где Shell – это родительское окно для данного окна, таким образом определяя создаваемое окно главным окном приложения.

Далее вызываются методы createActions, addToolBar, addMenuBar и addStatusLine.

Метод createActions предназначен для создания JFace-действий, а методы addToolBar, addMenuBar и addStatusLine являются методами класса ApplicationWindow и отвечают за определение конфигурации окна, имеющего панель инструментов, панель меню и строку статуса.

Метод createContents переопределяет соответствующий метод класса Window, являющегося суперклассом класса ApplicationWindow.

Данный метод отвечает за создание и возврат содержимого окна, и в переопределенном методе createContents создается и возвращается SWT контейнер Composite.

При добавлении компонентов в ApplicationWindow-окно приложения, используя область визуального редактирования вкладки Design WindowBuilder-редактора, код создания компонентов добавляется в метод createContents и компоненты становятся дочерними компонентами возвращаемого методом Composite-контейнера.

Метод createMenuManager переопределяет соответствующий метод класса ApplicationWindow.

Данный метод отвечает за создание и возврат объекта MenuManager – объекта-помощника, упрощающего создание и обновление меню.

Заполнить меню элементами можно используя раздел JFace Actions Palette-палитры вкладки Design WindowBuilder-редактора, который появляется в Palette-палитре при создании JFace-приложения.

Для добавления элемента меню перенесем элемент New раздела JFace Actions Palette-палитры в область (Empty MenuManager) холста дизайнера.

В результате в методе createActions появится код создания экземпляра анонимного класса, расширяющего класс Action, а в методе createMenuManager произойдет добавление созданного Action-объекта в панель меню методом add интерфейса IContributionManager, который реализуется классом MenuManager и который обеспечивает общий протокол для добавления, удаления и поиска элементов панели меню, панели инструментов и строки статуса.

После добавления, Action-объект отображается в виде кнопки панели меню.

Для того чтобы нажатие добавленной кнопки панели меню вызвало требуемое действие необходимо переопределить метод run класса Action, вызываемый средой выполнения при возникновении SWT-события.

Метод createToolBarManager переопределяет соответствующий метод класса ApplicationWindow.

Данный метод отвечает за создание и возврат объекта ToolBarManager – объекта-помощника, упрощающего создание и обновление панели инструментов.

Заполнить панель инструментов элементами можно, используя раздел JFace Actions Palette-палитры вкладки Design WindowBuilder-редактора.

Для добавления элемента панели инструментов перенесем элемент New раздела JFace Actions Palette-палитры в область (Empty ToolBarManager) холста дизайнера – в результате в методе createActions появится код создания экземпляра анонимного класса, расширяющего класс Action, а в методе createToolBarManager произойдет добавление созданного Action-объекта в панель инструментов методом add интерфейса IContributionManager, который реализуется классом ToolBarManager.

После добавления, Action-объект отображается в виде кнопки панели инструментов.

Для того чтобы нажатие добавленной кнопки панели инструментов вызвало требуемое действие, необходимо переопределить метод run класса Action, вызываемый средой выполнения при возникновении SWT-события.

Метод createStatusLineManager главного класса JFace-приложения переопределяет соответствующий метод класса ApplicationWindow.

Данный метод отвечает за создание и возврат объекта StatusLineManager – объекта-помощника, упрощающего создание и обновление строки статуса.

Класс ApplicationWindow имеет метод setStatus с параметром String message, который выводит сообщение в строку статуса и который можно использовать, например, в переопределенном методе run Action-класса.

Выводить сообщение в строку статуса также позволяет метод setMessage класса StatusLineManager, который также можно применить в переопределенном методе run Action-класса с помощью метода getStatusLineManager.setMessage.

Так как класс StatusLineManager реализует интерфейс IContributionManager, в строку статуса с помощью метода add можно добавлять Action-объекты.

Метод configureShell главного класса JFace-приложения переопределяет соответствующий метод класса ApplicationWindow, который отвечает за настройку конфигурации Shell-окна, являющегося основой ApplicationWindow-окна.

Здесь, в переопределенном методе configureShell устанавливается заголовок ApplicationWindow-окна приложения.

Метод getInitialSize переопределяет соответствующий метод класса Window, являющегося суперклассом класса ApplicationWindow.

Данный метод возвращает первоначальные размеры окна.

Для того чтобы изменения параметров возвращаемого данным методом объекта Point гарантировано работали, необходимо переопределить метод initializeBounds класса Window.

В методе main главного класса JFace-приложения – точке входа в приложение, создается экземпляр главного класса, затем вызывается метод setBlockOnOpen (true) класса Window, блокирующий возврат метода open, вызываемого далее.

Метод open класса Window создает и открывает окно, возвращая код OK или CANCEL.

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

После возврата метода open в методе main производится удаление Display-объекта.

Palette-палитра вкладки Design и область визуального редактирования WindowBuilder-редактора помогают наполнить ApplicationWindow-окно приложения необходимыми компонентами интерфейса пользователя.

XWT-платформа отделяет определение интерфейса в виде XML-документа от программной логики запуска и выполнения приложения.

Такое разделение декларативного описания интерфейса и бизнес-логики приложения дает преимущества в возможности повторного использования компонентов интерфейса и упрощает интеграцию с инструментами разработки.

Для создания XWT-приложения в окне Package Explorer нажмем правой кнопкой мышки на узле проекта, созданного с использованием мастера SWT/JFace Java Project, и в контекстном меню выберем команду New | Other | WindowBuilder | SWT Designer | XWT | XWT Application, нажмем кнопку Next, введем имя пакета и имя класса и нажмем кнопку Finish.

В результате будут сгенерированы два файла – Java-файл с исходным кодом главного класса приложения и одноименный XML-файл с описанием интерфейса приложения и расширением. xwt.

Кроме того, в путь приложения будут добавлены библиотеки XWT-платформы.

В статическом методе main главного класса XWT-приложения – точке входа в приложение получается URL-адрес XWT-файла описания интерфейса пользователя, используя метод getResource класса java.lang.Class и поле XWT_EXTENSION_SUFFIX (XWT_EXTENSION=«xwt») класса IConstants, содержащего общие XWT-константы.

Далее полученный URL-адрес XWT-файла передается в качестве аргумента методу load класса XWT, являющегося основным классом XWT-платформы.

Метод load класса XWT загружает содержимое XWT-файла, создает на его основе компоненты интерфейса и возвращает корневой компонент Control.

Корневой Control-компонент интерфейса дает возможность получить с помощью метода getShell корневое Shell-окно приложения для компоновки его дочерних компонентов методом layout класса Composite и его активизации методом open класса Shell.

Перед открытием Shell-окна в методе main вызывается метод centerInDisplay главного класса XWT-приложения, отвечающий за установку координат и размеров Shell-окна относительно Display-объекта.

При открытии XWT-файла в WindowBuilder-редакторе в области редактирования среды Eclipse появляются три вкладки: XML Source, Design и Bindings.

Вкладка XML Source отображает описание интерфейса в XML-формате, вкладка Design представляет визуальный графический редактор интерфейса, а вкладка Bindings обеспечивает создание и редактирование связывания данных.

Palette-палитра и область визуального редактирования вкладки Design позволяют наполнить главное окно XWT-приложения необходимыми компонентами интерфейса аналогично SWT и JFace приложению.

Для установки набора инструментов e (fx) clipse в поле Work with: команды Install New Software меню Help среды Eclipse выберем релиз среды Eclipse.

В поле фильтра введем e (fx) clipse.

Отметим флажок e (fx) clipse и нажмем кнопку Next.

После установки инструментов e (fx) clipse и перезапуска среды Eclipse в меню File выберем команду New | Other | JavaFX | JavaFX Project и нажмем кнопку Next.

Введем имя проекта, и нажмем кнопку Finish.

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

Здесь создается сцена, которая устанавливается для окна Stage.

Откроем файл fxbuild и заполним поля.

Нажмем ссылку Generate ant build. xml and run.

В результате будет собран исполняемый jar файл приложения.