Java 回转布局：垂直流动
我应该使用什么LayoutManager来实现FlowLayout的转置版本 本质上，我想要一个垂直列表，如果它不能在一列中容纳它的所有组件，它将占用多个列Java 回转布局：垂直流动,java,swing,Java,Swing,我应该使用什么LayoutManager来实现FlowLayout的转置版本 本质上，我想要一个垂直列表，如果它不能在一列中容纳它的所有组件，它将占用多个列 +------------------------+ | item 1 | | item 2 | | item 3 | | item 4 | | item 5 | | item 6
+------------------------+
| item 1 |
| item 2 |
| item 3 |
| item 4 |
| item 5 |
| item 6 |
| item 7 |
| item 8 |
+------------------------+
这种包装逻辑需要动态发生，即随着容器大小的调整。我将GridLayout修改为先按列而不是按行布局组件：
要么您需要一个自定义布局管理器，要么您可以使用GridBagLayout之类的工具来控制自己 例如：
Component parent = ...;
GridBagConstraints c = ...;
//set other parameters
c.gridx = 0;
c.gridy = 0;
parent.add([component1], c);
c.gridy++;
parent.add([component2], c);
c.gridy++;
我正在研究一个解决方案（非常类似：我需要垂直流动，但水平限制宽度），我得到了一个快速的工作示例，也许它可以让您从自定义布局管理器开始：
import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.LayoutManager2;
import java.util.Random;
import java.util.Set;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import com.google.common.collect.Sets;
public class VerticalFlowLayout implements LayoutManager2
{
final private Set<Component> components = Sets.newLinkedHashSet();
private int hgap = 0;
private int vgap = 0;
public void setHGap(int hgap) { this.hgap = hgap; }
public void setVGap(int vgap) { this.vgap = vgap; }
@Override public void addLayoutComponent(Component comp, Object constraints) {
this.components.add(comp);
}
/* these 3 methods need to be overridden properly */
@Override public float getLayoutAlignmentX(Container target) {
// TODO Auto-generated method stub
return 0;
}
@Override public float getLayoutAlignmentY(Container target) {
// TODO Auto-generated method stub
return 0;
}
@Override public void invalidateLayout(Container target) {
// TODO Auto-generated method stub
}
@Override public void addLayoutComponent(String name, Component comp) {
this.components.add(comp);
}
@Override public void layoutContainer(Container parent) {
int x = 0;
int y = 0;
int columnWidth = 0;
for (Component c : this.components)
{
if (c.isVisible())
{
Dimension d = c.getPreferredSize();
columnWidth = Math.max(columnWidth, d.width);
if (y+d.height > parent.getHeight())
{
x += columnWidth + this.hgap;
y = 0;
}
c.setBounds(x, y, d.width, d.height);
y += d.height + this.vgap;
}
}
}
/* these 3 methods need to be overridden properly */
@Override public Dimension minimumLayoutSize(Container parent) {
return new Dimension(0,0);
}
@Override public Dimension preferredLayoutSize(Container parent) {
return new Dimension(200,200);
}
@Override public Dimension maximumLayoutSize(Container target) {
return new Dimension(600,600);
}
@Override public void removeLayoutComponent(Component comp) {
this.components.remove(comp);
}
public static void main(String[] args) {
JFrame frame = new JFrame("VerticalFlowLayoutTest");
VerticalFlowLayout vfl = new VerticalFlowLayout();
JPanel panel = new JPanel(vfl);
vfl.setHGap(20);
vfl.setVGap(2);
int n = 19;
Random r = new Random(12345);
for (int i = 0; i < n; ++i)
{
JLabel label = new JLabel(labelName(i,r));
panel.add(label);
}
frame.setContentPane(panel);
frame.pack();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true);
}
private static String labelName(int i, Random r) {
StringBuilder sb = new StringBuilder();
sb.append("label #");
sb.append(i);
sb.append(" ");
int n = r.nextInt(26);
for (int j = 0; j < n; ++j)
sb.append("_");
return sb.toString();
}
}
导入java.awt.Component；
导入java.awt.Container；
导入java.awt.Dimension；
导入java.awt.LayoutManager2；
导入java.util.Random；
导入java.util.Set；
导入javax.swing.JFrame；
导入javax.swing.JLabel；
导入javax.swing.JPanel；
导入com.google.common.collect.set；
公共类VerticalFlowLayout实现LayoutManager2
{
final private Set components=Sets.newLinkedHashSet（）；
私有int hgap=0；
私有int vgap=0；
public void setHGap（int hgap）{this.hgap=hgap；}
public void setVGap（int vgap）{this.vgap=vgap；}
@替代公共void addLayoutComponent（组件组件、对象约束）{
本.组件.添加（comp）；
}
/*这3种方法需要正确地重写*/
@重写公共浮点getLayoutAlignmentX（容器目标）{
//TODO自动生成的方法存根
返回0；
}
@重写公共浮点GetLayoutAlignment（容器目标）{
//TODO自动生成的方法存根
返回0；
}
@覆盖公共void invalidateLayout（容器目标）{
//TODO自动生成的方法存根
}
@重写公共void addLayoutComponent（字符串名称，组件组成）{
本.组件.添加（comp）；
}
@覆盖公共无效布局容器（容器父级）{
int x=0；
int y=0；
int columnWidth=0；
对于（组件c：此.components）
{
如果（c.isVisible（））
{
维度d=c.getPreferredSize（）；
columnWidth=数学最大值（columnWidth，d.width）；
如果（y+d.height>parent.getHeight（））
{
x+=列宽+this.hgap；
y=0；
}
c、 立根（x、y、d.宽度、d.高度）；
y+=d.高度+此.V间隙；
}
}
}
/*这3种方法需要正确地重写*/
@替代公共维度minimumLayoutSize（容器父级）{
返回新维度（0,0）；
}
@替代公共维度preferredLayoutSize（容器父级）{
返回新维度（200200）；
}
@覆盖公共维度maximumLayoutSize（容器目标）{
返回新尺寸（600600）；
}
@覆盖公共void removeLayoutComponent（组件组件组件）{
此。组件。移除（comp）；
}
公共静态void main（字符串[]args）{
JFrame frame=新JFrame（“垂直流动布局测试”）；
VerticalFlowLayout vfl=新的VerticalFlowLayout（）；
JPanel面板=新JPanel（vfl）；
vfl.setHGap（20）；
vfl.setVGap（2）；
int n=19；
随机r=新随机（12345）；
对于（int i=0；iyourPanel.setLayout(new BoxLayout(yourPanel, BoxLayout.Y_AXIS));
包通用；
/**
*@作者帕斯班
*/
导入java.awt.*；
导入java.util.*；
公共类VerticalLayout实现LayoutManager{
公共最终静态整数中心=0；
公共最终静态整数右=1；
公共最终静态int左=2；
公共最终静态int均=3；
公共最终静态int TOP=1；
公共最终静态int-BOTTOM=2；
私营部门；
私有int对齐；
私人int锚；
私有哈希表comps；
公共垂直布局（）{
这（5，中间，顶部）；
}
公共垂直布局（int vgap）{
这（间隙、中心、顶部）；
}
公共垂直布局（内部垂直间距、内部对齐）{
这（间隙、对齐、顶部）；
}
公共垂直布局（内部垂直间距、内部对齐、内部锚定）{
this.vgap=vgap；
这个。对齐=对齐；
this.anchor=锚；
}
专用维度layoutSize（容器父级，最小布尔值）{
尺寸标注=新尺寸标注（0,0）；
维度d；
已同步（父级.getTreeLock（））{
int n=parent.getComponentCount（）；
对于（int i=0；i0）
yourPanel.setLayout(new BoxLayout(yourPanel, BoxLayout.Y_AXIS));
package Common;
/**
* @author Pasban
*/
import java.awt.*;
import java.util.*;
public class VerticalLayout implements LayoutManager {
public final static int CENTER = 0;
public final static int RIGHT = 1;
public final static int LEFT = 2;
public final static int BOTH = 3;
public final static int TOP = 1;
public final static int BOTTOM = 2;
private int vgap;
private int alignment;
private int anchor;
private Hashtable comps;
public VerticalLayout() {
this(5, CENTER, TOP);
}
public VerticalLayout(int vgap) {
this(vgap, CENTER, TOP);
}
public VerticalLayout(int vgap, int alignment) {
this(vgap, alignment, TOP);
}
public VerticalLayout(int vgap, int alignment, int anchor) {
this.vgap = vgap;
this.alignment = alignment;
this.anchor = anchor;
}
private Dimension layoutSize(Container parent, boolean minimum) {
Dimension dim = new Dimension(0, 0);
Dimension d;
synchronized (parent.getTreeLock()) {
int n = parent.getComponentCount();
for (int i = 0; i < n; i++) {
Component c = parent.getComponent(i);
if (c.isVisible()) {
d = minimum ? c.getMinimumSize() : c.getPreferredSize();
dim.width = Math.max(dim.width, d.width);
dim.height += d.height;
if (i > 0) {
dim.height += vgap;
}
}
}
}
Insets insets = parent.getInsets();
dim.width += insets.left + insets.right;
dim.height += insets.top + insets.bottom + vgap + vgap;
return dim;
}
public void layoutContainer(Container parent) {
Insets insets = parent.getInsets();
synchronized (parent.getTreeLock()) {
int n = parent.getComponentCount();
Dimension pd = parent.getSize();
int y = 0;
for (int i = 0; i < n; i++) {
Component c = parent.getComponent(i);
Dimension d = c.getPreferredSize();
if (c.isVisible()) {
y += d.height + vgap;
}
}
y -= vgap;
if (anchor == TOP) {
y = insets.top;
} else if (anchor == CENTER) {
y = (pd.height - y) / 2;
} else {
y = pd.height - y - insets.bottom;
}
for (int i = 0; i < n; i++) {
Component c = parent.getComponent(i);
Dimension d = c.getPreferredSize();
if (!c.isVisible()) {
continue;
}
int x = 1;
int wid = pd.width - 3;
c.setBounds(x, y, wid, d.height);
y += d.height + vgap;
}
}
}
public Dimension minimumLayoutSize(Container parent) {
return layoutSize(parent, false);
}
public Dimension preferredLayoutSize(Container parent) {
return layoutSize(parent, false);
}
public void addLayoutComponent(String name, Component comp) {
}
public void removeLayoutComponent(Component comp) {
}
public String toString() {
return getClass().getName() + "[vgap=" + vgap + " align=" + alignment + " anchor=" + anchor + "]";
}
}
final private Set<Component> components = Sets.newLinkedHashSet();
final private List<Component> components = new LinkedList<>();