IP Software Книги и Статьи Обсуждение

Многооконное окружение

В этой главе мы обсудим средства построение многооконных, или многодокументных, приложений (Multiple Document Interface, MDI) средствами Swing. Как известно, окно в современных графических операционных системах используются для разделения задач, выполняемых пользователем, в одном из окон он может редактировать текст, в другом окне просматривать фотографии. Использование окон позволяет ему временно забыть про остальные свои задачи, не смешивая их, заниматься основным делом (в терминах оконной системы это будет активное в данный момент окно), и, как только возникает необходимость, переместиться к другой задаче (сделав активным другое окно, то есть вытащив его на первый план и временно убрав на задний план все остальное).

 

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

 

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

 

Создание внутренних окон

Внутренние окна в Swing реализованы классом JInternalFrame. Данный класс унаследован от общего предка всех компонентов Swing JComponent, и, таким образом, представляет собой обычный легковесный компонент, который вы при желании можете добавить в любую панель или окно вашего приложения. Так как данный компонент призван эмулировать окно внутри приложения, у него есть элементы управления, такие как меню окна, кнопки для закрытия, развертывания и свертывания, а также заголовок и рамка. Роль рабочего стола, на котором окна размещаются, внутри которого перемещаются и занимают его пространство, исполняет компонент JDesktopPane. Давайте рассмотрим пример:

// SimpleMDI.java

// Демонстрация внутренних окон Swing и рабочего стола JDesktopPane

import javax.swing.*;

 

public class SimpleMDI extends JFrame {

    public SimpleMDI() {

        super("SimpleMDI");

        setSize(400, 300);

        setDefaultCloseOperation(EXIT_ON_CLOSE);

        // создаем рабочий стол Swing

        JDesktopPane desktopPane = new JDesktopPane();

        // добавляем его в центр окна

        add(desktopPane);

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

        JInternalFrame frame1 = new JInternalFrame("Frame1", true);

        JInternalFrame frame2 = new JInternalFrame(

"Frame2", true, true, true, true);

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

        desktopPane.add(frame1);

        desktopPane.add(frame2);

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

        frame1.setSize(200, 100);

        frame1.setLocation(80, 100);

        frame1.setVisible(true);

        frame2.setSize(200, 60);

        frame2.setVisible(true);

        // выводим окно на экран

        setVisible(true);

    }

    public static void main(String[] args) {

        new SimpleMDI();

    }

}

В обычном окне JFrame размещается рабочий стол JDesktopPane. Как видно, никаких параметров конструктору не требуется, так же как не требуется для нормальной работы и дополнительной настройки. О  рабочем столе можно думать как о специализированной панели, специально предназначенной для размещения и управления внутренними окнами. Мы добавляем его в центр окна методом add() напрямую, используя возможность Swing (с версий JDK 1.5) не упоминать больше ставший уже легендарным метод getContentPane().

Далее создаются внутренние окна. Интересно что класс JInternalFrame обладает целым букетом конструкторов с различным набором параметров, которые позволяют задать все атрибуты внутренних окон. Обязательно присутствует лишь заголовок окна (как первый параметр всех конструкторов).

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

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

Внутренние окна стараются во всем походить на своих старших братьев – окна высокого уровня, унаследованные от Window, и поэтому они по умолчанию невидимы, имеют нулевой размер и располагаются в начале экрана. Работа с внутренними окнами здесь не отличается от работы с обычными. Мы меняем размер окон, устанавливаем их позиции и делаем их видимыми. Только после этого они появятся на рабочем столе JDesktopPane.

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

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

 

Внутренние окна – полноценные окна Swing

Мы уже видим, что внутренние окна по сути стараются далеко не отходить от обычных окон Swing. Если взглянуть поглубже, это станет еще более очевидным. Основным качеством окон является присутствие в них корневой панели, которая, как мы знаем, состоит из нескольких составляющих, и позволяет окнам быть окнами, в том числе отображать полоску меню и контекстные меню. Внутренние окна содержат корневую панель как основной компонент, и для Swing это означает что они являются обычными окнами, просто без связи с операционной системой. К примеру, в старых версиях Swing добавлять в них компоненты нужно было все через тот же вызов getContentPane(), а не через прямой вызов add(), что вызвало бы исключение.

Как и у обычных окон, мы найдем во внутренних окнах такие свойства как rootPane, contentPane, defaultCloseOperation, title и соответствующие методы get и set. Все они имеют тоже значение что и в обычных окнах – мы можем управлять корневой панелью, добавлять компоненты в панель содержимого и менять в ней менеджер расположения, устанавливать действие по закрытию окна и менять его заголовок. Как и в обычном окне, во внутреннем мы можем организовать систему меню любой сложности и добавить его, применив свойство JMenuBar.

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

Название свойства

Описание

frameIcon

Задает значок для внутреннего окна, в том случае если представитель UI окон поддерживает значки

iconifiable

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

resizable

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

maximizable

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

closable

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

 

События внутренних окон

 


Все права защищены, Компания IT Panthers Software, 2008 год
Вопросы, касающиеся данного веб-сайта, можно обсудить, написав письмо по адресу webmaster@ipsoftware.ru