Как Использовать GroupLayout

GroupLayout менеджер по расположению, который был разработан для разработчиков GUI, таких как Матисс, разработчик GUI, предоставленный IDE NetBeans. Хотя менеджер по расположению был первоначально разработан, чтобы подойти разработчику GUI потребности, это также работает хорошо на ручное кодирование. Это обсуждение будет учить Вас как GroupLayout работы и шоу Вы, как можно использовать GroupLayout создавать GUI, хотите ли Вы использовать разработчика GUI как Матисс или писать Ваш собственный код.

Если Вы интересуетесь использованием JavaFX, чтобы создать Ваш GUI, см. Работу С Разметками в JavaFX.

Принцип разработки: Независимые Размерности

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

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

Организация расположения: Hierarchical Groups

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

1. С последовательным расположением компоненты просто помещаются один за другим, точно так же как BoxLayout или FlowLayout сделал бы вдоль одной оси. Позиция каждого компонента определяется как являющийся относительно предыдущего компонента.
2. Второй путь помещает компоненты параллельно — друг на друга в том же самом пространстве. Они могут быть базовой линией - вершина - или выровненный нижней частью вдоль вертикальной оси. Вдоль горизонтальной оси они могут быть лево-, правильными - или выровненный центром, если компоненты не являются всеми одинаковыми размер.

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

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

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

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

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

Пример

Давайте запустим с чего-то простого, только три компонента подряд:

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

В псевдо коде спецификация расположения могла бы быть похожей на это (реальный код находится в разделе Кода Записи ниже):

horizontal layout = sequential group { c1, c2, c3 }
vertical layout = parallel group (BASELINE) { c1, c2, c3 }

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

Теперь давайте добавим еще один компонент, C4, выровненный по левому краю с C3:

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

В псевдо коде спецификация расположения теперь похожа на это:

horizontal layout = sequential group { c1, c2, parallel group (LEFT) { c3, c4 } }
vertical layout = sequential group { parallel group (BASELINE) { c1, c2, c3 }, c4 }

Теперь Вы понимаете самые важные аспекты разработки разметок с GroupLayout. Есть только еще несколько деталей, чтобы объяснить: как добавить разрывы, как определить размер и изменить размеры поведения, как определить выровненное по ширине расположение, и как записать реальный код.

Разрывы

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

GroupLayout также определяет автоматические разрывы, которые соответствуют привилегированным расстояниям между соседними компонентами (или между компонентом и контейнерной границей). Размер такого разрыва вычисляется динамически основанный на стили, который использует приложение ( LayoutStyle class используется для этого). Есть два преимущества для использования автоматических (привилегированных) разрывов: Вы не должны определить пиксельные размеры разрывов, и они автоматически корректируют к стили выполнения UI с, отражая фактические направляющие линии стили.

GroupLayout отличает между (a) привилегированный разрыв между двумя компонентами и (b) привилегированный разрыв между компонентом и контейнерной границей. Есть соответствующие методы в GroupLayout API для того, чтобы добавить эти разрывы (addPreferredGap и addContainerGap). Есть три типа компонентных разрывов: связанный, не связанный и расположенный с отступом. LayoutStyle.ComponentPlacement перечисление определяет соответствующие константы, которые будут использоваться в качестве параметров addPreferredGap метод: RELATED, UNRELATED и INDENT. Различие между связанными и несвязанными разрывами находится только в размере — расстояние между несвязанными компонентами немного больше. Расположенный с отступом представляет привилегированное горизонтальное расстояние двух компонентов, когда один из них располагается под вторым с отступом.

Как упомянуто выше, GroupLayout может вставить разрывы автоматически — если Вы не добавляете свои собственные разрывы явно, это добавляет связанные привилегированные разрывы для Вас. Это не поведение значения по умолчанию, как бы то ни было. Необходимо включить эту функцию, вызывая setAutoCreateGaps(true) и setAutoCreateContainerGaps(true) на GroupLayout. Затем Вы получите корректный интервал автоматически.

Запись Кода

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

Давайте предполагать, что у нас есть названный контейнер panel и те же самые четыре компонента, уже представленные (c1, c2, c3, и c4). Во-первых, мы создаем новое GroupLayout объект и партнер это с панелью:

GroupLayout layout = new GroupLayout(panel);
 panel.setLayout(layout);

Мы определяем автоматическую вставку разрыва:

layout.setAutoCreateGaps(true);
layout.setAutoCreateContainerGaps(true);

Затем, мы определяем группы и добавляем компоненты. Мы устанавливаем корневую группу для каждой размерности, используя setHorizontalGroup и setVerticalGroup методы. Группы создаются через createSequentialGroup и createParallelGroup методы. Компоненты добавляются к группам при использовании addComponent метод.

layout.setHorizontalGroup(
   layout.createSequentialGroup()
      .addComponent(c1)
      .addComponent(c2)
      .addGroup(layout.createParallelGroup(GroupLayout.Alignment.LEADING)
           .addComponent(c3)
           .addComponent(c4))
);
layout.setVerticalGroup(
   layout.createSequentialGroup()
      .addGroup(layout.createParallelGroup(GroupLayout.Alignment.BASELINE)
           .addComponent(c1)
           .addComponent(c2)
           .addComponent(c3))
      .addComponent(c4)
);

Можно определить выравнивание для параллельных групп. Это может быть одна из следующих констант, определенных в GroupLayout.Alignment перечисление: LEADING, TRAILING, CENTER, и BASELINE. Эти константы используются для обеих размерностей и зависят от того, является ли компонентная ориентация слева направо или справа налево (от начала до конца или нижняя часть к вершине). Например, если горизонталь (вертикаль) компонентная ориентация слева направо (от начала до конца) LEADING средства, оставленные (вершину), в то время как TRAILING право средств (нижняя часть). CENTER означает "центрируемый" в обеих размерностях. Если Вы не определяете выравнивание, LEADING будет использоваться. BASELINE выравнивание допустимо только в измерении по вертикали.

Некоторые комментарии о коде:

• Вы не должны добавить компонент непосредственно к контейнеру — который делается для Вас неявно при использовании одного из addComponent методов.
• Отметьте цепочечные вызовы addComponent методы, используемые, чтобы заполнить группы. addComponent метод всегда возвращает группу, на которой его вызывают. Благодаря этому Вы не должны использовать локальные переменные, чтобы содержать группы.
• Это - хорошая идея расположить код с отступом, таким образом, легко видеть иерархическую структуру групп. Дайте каждому компоненту новую строку, добавьте один уровень отступа для каждой новой группы в иерархии. Хороший редактор исходного кода поможет Вам с соединением круглой скобки закрыться createXXXGroup методы. Следующим эти простые правила легче добавить новый компонент или удалить существующий.

Компонент Size и Resizability

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

Размер каждого компонента в a GroupLayout ограничивается тремя значениями; минимальный размер, предпочтенный размер и максимальный размер. Эти размеры управляют, как компонент изменяет размеры в пределах расположения. GroupLayout.addComponent(...) метод позволяет ограничениям размера быть определенными.

Если не определенный явно, расположение просит у компонента свои размеры значения по умолчанию (при использовании компонента getMinimumSize(), getPreferredSize() и getMaximumSize() методы). Вы ничего не должны определить для большинства компонентов, как создание JTextField изменяемого размера или JButton фиксированный, потому что у самих компонентов есть требуемое поведение изменения размеров как значение по умолчанию. С другой стороны можно переопределить поведение значения по умолчанию. Например можно сделать a JTextField фиксированный или JButton изменяемого размера.

GroupLayout определяет константы, которые обеспечивают, точное управление изменяют размеры поведения. Они могут использоваться в качестве параметров в addComponent(Component comp, int min, int pref, int max) метод. Вот два примера:

1. Вынудить компонент быть изменяемого размера (позволяют уменьшаться и расти):

   group.addComponent(component, 0, GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) ...
   

   Это позволяет компоненту изменять размеры между нулевым размером (минимум) к любому размеру (Short.MAX_VALUE как максимальный размер означает "бесконечный"). Если бы мы хотели, чтобы компонент не уменьшился ниже его размера минимума значения по умолчанию, то мы использовали бы GroupLayout.DEFAULT_SIZE вместо 0 во втором параметре.

2. Сделать компонентный фиксированный размер (подавляют изменение размеров):

   group.addComponent(component, GroupLayout.PREFERRED_SIZE, GroupLayout.DEFAULT_SIZE,
             GroupLayout.PREFERRED_SIZE) ...
   

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

Разрывы изменяемого размера

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

layout.createSequentialGroup()
    .addComponent(c1)
    .addPreferredGap(LayoutStyle.ComponentPlacement.RELATED,
                     GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
    .addComponent(c2);

Калибровка в параллельных Группах

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

Давайте попытаемся достигнуть того же самого размера для двух компонентов от нашего примера (c3 и c4 в измерении по горизонтали):

layout.createParallelGroup(GroupLayout.Alignment.LEADING, false)
  .addComponent(c3, GroupLayout.DEFAULT_SIZE, GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
  .addComponent(c4, GroupLayout.DEFAULT_SIZE, GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE);

Базовый механизм работает следующим образом:

1. Размер параллельной группы устанавливается в привилегированный размер самого большого элемента; так к привилегированному размеру c4 в нашем примере.
2. Элементы изменяемого размера расширяются к размеру группы. В нашем примере, только c3 эффективно расширяется, размер c4 уже соответствует размеру группы.

В результате c3 и c4 имел бы тот же самый width. Компоненты не изменили бы размеры далее, потому что сама параллельная группа не изменяемого размера (второй параметр createParallelGroup метод, выше, false).

Вопрос для внимательных читателей: Почему мы определяем оба компонента в параллельной группе как изменяемого размера в этом примере? Это кажется достаточно, чтобы иметь только c3 изменяемого размера с тех пор c4 не расширяется так или иначе...

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

Создание Компонентов Тот же самый Размер

Предыдущий случай является особенным, потому что компоненты находятся в той же самой параллельной группе. Но что, если мы хотели, чтобы у несвязанных компонентов был тот же самый размер? Ясно, тот же самый размер не может всегда обеспечиваться, группируясь. OK и кнопки Cancel подряд у основания диалогового окна являются хорошим примером. С этой целью GroupLayout обеспечивает a linkSize метод. Этот метод позволяет размеру произвольных компонентов быть соединенным независимо от того, куда они размещаются. Получающийся размер соединенных компонентов устанавливается согласно самому большому компоненту. Например:

layout.linkSize(SwingConstants.HORIZONTAL, c3, c4);

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

Время выполнения Изменяется на Ваш GUI

Есть два важных метода, которые можно использовать, чтобы произвести изменения в Вашем GUI во времени выполнения, replace() и setHonorsVisibility(). Используя эти два метода, можно обмениваться компонентами или изменить видимость компонентов во времени выполнения и иметь GUI, перестраивают себя соответственно.

replace(Component existingComponent, Component newComponent) заменяет существующий компонент новым. Одна из общих операций, необходимых для динамических разметок, является возможностью заменить компоненты как это. Например, возможно флажок переключается между компонентом, выводящим на экран график или дерево. GroupLayout делает этот сценарий простым с replace() метод. Можно подкачать компоненты, не воссоздавая все группы.

Другая общая работа в пользовательских интерфейсах должна динамически изменить видимость компонентов. Возможно, компоненты показывают только, поскольку пользователь завершает более ранние части формы. Чтобы избежать компонентной перестановки вокруг в таком сценарии, пространство должно быть приведено в рабочее состояние независимо от видимости компонентов. GroupLayout предложения два способа сконфигурировать, как обрабатываются невидимые компоненты. setHonorsVisibility(boolean) метод глобально устанавливает, как обрабатываются невидимые компоненты. Значение истины, значения по умолчанию, указывает, что невидимые компоненты обрабатываются, как будто они не там. С другой стороны значение лжи обеспечивает пространство для невидимых компонентов, обрабатывая их, как если бы они были видимы. setHonorsVisibility(Component,Boolean) метод может использоваться, чтобы сконфигурировать поведение на уровне определенного компонента. Определить, как видимость обрабатывается, GroupLayout первые проверки, если значение было определено для Компонента, в противном случае это проверяет установку глобального свойства.