From 0271a2918a0985f7b47a4c784a8670a564af15ed Mon Sep 17 00:00:00 2001
From: Keiko Katsuragawa <kkatsuragawa@uwaterloo.ca>
Date: Thu, 25 Jan 2018 20:32:32 -0500
Subject: [PATCH] add 2-6-Layout
---
java/2-6-Layout/DemoAlignLayout.java | 214 ++++++++++++++++
java/2-6-Layout/DemoFormLayout.java | 286 ++++++++++++++++++++++
java/2-6-Layout/LayoutDemo.java | 351 +++++++++++++++++++++++++++
java/2-6-Layout/makefile | 15 ++
4 files changed, 866 insertions(+)
create mode 100644 java/2-6-Layout/DemoAlignLayout.java
create mode 100644 java/2-6-Layout/DemoFormLayout.java
create mode 100644 java/2-6-Layout/LayoutDemo.java
create mode 100644 java/2-6-Layout/makefile
diff --git a/java/2-6-Layout/DemoAlignLayout.java b/java/2-6-Layout/DemoAlignLayout.java
new file mode 100644
index 0000000..262e4ae
--- /dev/null
+++ b/java/2-6-Layout/DemoAlignLayout.java
@@ -0,0 +1,214 @@
+import java.awt.*;
+import javax.swing.*;
+
+import java.awt.LayoutManager;
+import java.awt.Insets;
+import java.util.ArrayList;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+
+// give positions and sizes for all widgets
+public class DemoAlignLayout extends JFrame {
+
+ public static void main(String[] args) {
+ DemoAlignLayout demo = new DemoAlignLayout();
+ }
+
+ DemoAlignLayout() {
+
+ this.setSize(800, 300);
+ this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+ // layout
+ this.setLayout(new AlignLayout(40, 40));
+
+ // add components
+ JComponent c;
+ c = new JLabel("Number");
+ // try uncommenting this
+ // c.setPreferredSize(new Dimension(200, 50));
+ debugBorder(c);
+ this.add(c);
+
+ c = new JSlider(0, 100, 50);
+ debugBorder(c);
+ this.add(c);
+
+ c = new JLabel("Choice");
+ debugBorder(c);
+ this.add(c);
+
+ // create a radio button group
+ ButtonGroup radiobuttons = new ButtonGroup();
+ JPanel radioPanel = new JPanel(new GridLayout(1, 0));
+ for (String s: new String[] {"A", "B", "C"})
+ {
+ JRadioButton rb = new JRadioButton(s);
+ radiobuttons.add(rb);
+ radioPanel.add(rb);
+ }
+ debugBorder(radioPanel);
+ this.add(radioPanel);
+
+ System.out.println("Preferred size: " + this.getPreferredSize());
+ System.out.println("Minimum size: " + this.getMinimumSize());
+
+ this.setVisible(true);
+ }
+
+ // I made this to make it easy to add some debug information
+ void debugBorder(JComponent c) {
+ // try uncommenting this
+ c.setBorder(BorderFactory.createLineBorder(Color.black));
+ }
+}
+
+
+
+/**
+ * A layout manager that arranges components in a horizontal line equally spaced
+ * and centred vertically in the parent container.
+ */
+class AlignLayout implements LayoutManager {
+
+ int minimumSpacing;
+ int preferredSpacing;
+
+ /** Construct a new AlignLayout object with spacing between components. */
+ public AlignLayout(int minSpacing, int preferredSpacing) {
+ super();
+ this.minimumSpacing = minimumSpacing;
+ this.preferredSpacing = preferredSpacing;
+ }
+
+ // for specialized layouts, not used here
+ public void addLayoutComponent(String name, Component comp) { }
+ public void removeLayoutComponent(Component comp) { }
+
+ /**
+ * Calculates the preferred size dimensions for the specified panel given
+ * the components in the specified parent container.
+ */
+ public Dimension preferredLayoutSize(Container parent) {
+
+ synchronized (parent.getTreeLock()) {
+
+ // get space needed for all children
+ Dimension space = calculateSpace(parent, true);
+
+ // this container's padding
+ Insets insets = parent.getInsets();
+
+ Dimension d = new Dimension(insets.left + space.width +insets.right,
+ insets.top + space.height + insets.bottom);
+ return d;
+ }
+ }
+
+
+ /**
+ * Calculates the minimum size dimensions for the specified panel given the
+ * components in the specified parent container.
+ */
+ public Dimension minimumLayoutSize(Container parent) {
+
+ synchronized (parent.getTreeLock()) {
+
+ // get space needed for all children
+ Dimension space = calculateSpace(parent, false);
+
+ // this container's padding
+ Insets insets = parent.getInsets();
+
+ Dimension d = new Dimension(insets.left + space.width +insets.right,
+ insets.top + space.height + insets.bottom);
+ return d;
+ }
+ }
+
+
+ /**
+ * Lays out the container in the specified panel.
+ */
+ public void layoutContainer(Container parent) {
+
+ synchronized (parent.getTreeLock()) {
+
+ // get space needed for all children (preferred)
+ Dimension space = calculateSpace(parent, true);
+
+ // this container's padding
+ Insets insets = parent.getInsets();
+
+ // get actual space available in parent
+ int w = parent.getWidth() - insets.left - insets.right;
+ int h = parent.getHeight() - insets.top - insets.bottom;
+
+ System.out.println("layoutContainer (parent size " + w + "," + h + ")");
+
+ // vertical centre line to layout component
+ int y = h / 2;
+
+ // starting x is left side of all components to lay out
+ int x = (w - space.width) / 2;
+
+ int nComponents = parent.getComponentCount();
+ for (int i = 0; i < nComponents; i++) {
+
+ Component c = parent.getComponent(i);
+
+ Dimension d = c.getPreferredSize();
+
+ c.setBounds(x, y - d.height / 2, d.width, d.height);
+
+ x += d.width + preferredSpacing;
+ }
+
+ }
+ }
+
+
+ /*
+ * Precondition: the caller has gotten the treelock.
+ */
+ private Dimension calculateSpace(Container parent, boolean isPreferred) {
+
+ // find total width for all components and
+ // height of tallest component
+ Dimension result = new Dimension(0,0);
+
+ int nComponents = parent.getComponentCount();
+ for (int i = 0; i < nComponents; i++) {
+
+ Dimension d;
+ if (isPreferred) {
+ d = parent.getComponent(i).getPreferredSize();
+ } else {
+ d = parent.getComponent(i).getMinimumSize();
+ }
+ // update the total width and height required
+ result.width += d.width;
+ result.height = Math.max(result.height, d.height);
+ }
+
+ // add spacing in between components
+ if (isPreferred) {
+ result.width += (nComponents - 1) * preferredSpacing;
+ } else {
+ result.width += (nComponents - 1) * minimumSpacing;
+ }
+
+ return result;
+ }
+
+
+
+
+
+}
+
+
+
+
+
diff --git a/java/2-6-Layout/DemoFormLayout.java b/java/2-6-Layout/DemoFormLayout.java
new file mode 100644
index 0000000..07bb6d2
--- /dev/null
+++ b/java/2-6-Layout/DemoFormLayout.java
@@ -0,0 +1,286 @@
+import java.awt.*;
+import javax.swing.*;
+
+import java.awt.LayoutManager;
+import java.awt.Insets;
+import java.util.ArrayList;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+
+// give positions and sizes for all widgets
+public class DemoFormLayout extends JFrame {
+
+ public static void main(String[] args) {
+ DemoFormLayout demo = new DemoFormLayout();
+ }
+
+ DemoFormLayout() {
+
+ this.setSize(400, 150);
+ this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+
+ // layout
+ this.setLayout(new FormLayout(10, 10));
+
+ // add first pair
+ JComponent c;
+ c = new JLabel("Number");
+ // try uncommenting this
+ // c.setPreferredSize(new Dimension(200, 50));
+ debugBorder(c);
+ this.add(c);
+
+ c = new JSlider(0, 100, 50);
+ debugBorder(c);
+ this.add(c);
+
+ // add second pair
+ c = new JLabel("Choice");
+ debugBorder(c);
+ this.add(c);
+
+ // create a radio button group
+ ButtonGroup radiobuttons = new ButtonGroup();
+ JPanel radioPanel = new JPanel(new GridLayout(1, 0));
+ for (String s: new String[] {"A", "B", "C"})
+ {
+ JRadioButton rb = new JRadioButton(s);
+ radiobuttons.add(rb);
+ radioPanel.add(rb);
+ }
+ debugBorder(radioPanel);
+ this.add(radioPanel);
+
+ this.setVisible(true);
+ }
+
+ void debugBorder(JComponent c) {
+ // try uncommenting this
+ // c.setBorder(BorderFactory.createLineBorder(Color.black));
+ }
+}
+
+
+
+/**
+ * A layout manager that arranges components in a double column. In most cases
+ * the left column will hold a label and the right column will hold a component
+ * the user can manipulate. Preferred component sizes are respected as much as
+ * possible. Components in the left column are right justified; components in
+ * the right column are left justified.
+ *
+ * @author Byron Weber Becker
+ */
+class FormLayout implements LayoutManager {
+
+ private int hGap = 8;
+ private int vGap = 8;
+
+ /** Construct a new FormLayout object. */
+ public FormLayout() {
+ super();
+ }
+
+ /**
+ * Construct a new FormLayout object.
+ *
+ * @param hGap
+ * the number of hortizontal pixels between components
+ * @param vGap
+ * the number of vertical pixels between components
+ */
+ public FormLayout(int hGap, int vGap) {
+ super();
+ this.hGap = hGap;
+ this.vGap = vGap;
+ }
+
+ /**
+ * Adds the specified component with the specified name to the layout.
+ *
+ * @param name
+ * the component name
+ * @param comp
+ * the component to be added
+ */
+ public void addLayoutComponent(String name, Component comp) {
+ }
+
+ /**
+ * Removes the specified component from the layout.
+ *
+ * @param comp
+ * the component to be removed
+ */
+ public void removeLayoutComponent(Component comp) {
+ }
+
+ /**
+ * Calculates the preferred size dimensions for the specified panel given
+ * the components in the specified parent container.
+ *
+ * @param parent
+ * the component to be laid out
+ *
+ * @see #minimumLayoutSize
+ */
+ public Dimension preferredLayoutSize(Container parent) {
+ synchronized (parent.getTreeLock()) {
+ ColDims cd = colDims(parent, true);
+
+ Insets insets = parent.getInsets();
+ Dimension d = new Dimension(cd.left + cd.right + insets.left
+ + insets.right, cd.height + insets.top + insets.bottom);
+ return d;
+ }
+ }
+
+ /*
+ * Precondition: the caller has gotten the treelock. preferred = true for
+ * preferred sizes; false for minimum sizes
+ */
+ private ColDims colDims(Container parent, boolean preferred) {
+
+ // ColDims: left col width, right col width, height of all rows
+ ColDims cd = new ColDims();
+
+ int nComponents = parent.getComponentCount();
+
+ // step through rows (every other component)
+ for (int i = 1; i < nComponents; i += 2) {
+
+ Component left = parent.getComponent(i - 1);
+ Component right = parent.getComponent(i);
+
+ Dimension dLeft;
+ Dimension dRight;
+
+ if (preferred) {
+ dLeft = left.getPreferredSize();
+ dRight = right.getPreferredSize();
+ } else {
+ dLeft = left.getMinimumSize();
+ dRight = right.getMinimumSize();
+ }
+ cd.left = (int) Math.max(cd.left, dLeft.width);
+ cd.right = (int) Math.max(cd.right, dRight.width);
+ cd.height += (int) Math.max(dLeft.height, dRight.height);
+ cd.height += this.vGap;
+ }
+
+ // edge case (odd number of components...)
+ if (nComponents % 2 == 1) { // get the last one on the left
+ Component left = parent.getComponent(nComponents - 1);
+
+ Dimension dLeft;
+ if (preferred) {
+ dLeft = left.getPreferredSize();
+ } else {
+ dLeft = left.getMinimumSize();
+ }
+ cd.left = (int) Math.max(cd.left, dLeft.width);
+ cd.height += dLeft.height + this.vGap;
+ }
+
+ cd.left += this.hGap / 2;
+ cd.right += this.hGap / 2;
+ return cd;
+ }
+
+ /**
+ * Calculates the minimum size dimensions for the specified panel given the
+ * components in the specified parent container.
+ *
+ * @param parent
+ * the component to be laid out
+ * @see #preferredLayoutSize
+ */
+ public Dimension minimumLayoutSize(Container parent) {
+ synchronized (parent.getTreeLock()) {
+ ColDims cd = colDims(parent, false);
+
+ Insets insets = parent.getInsets();
+ Dimension d = new Dimension(cd.left + cd.right + insets.left
+ + insets.right, cd.height + insets.top + insets.bottom);
+ return d;
+ }
+ }
+
+ /**
+ * Lays out the container in the specified panel.
+ *
+ * @param parent
+ * the component which needs to be laid out
+ */
+ public void layoutContainer(Container parent) {
+ Insets insets = parent.getInsets();
+
+ synchronized (parent.getTreeLock()) {
+ ColDims cd = this.colDims(parent, true);
+
+ int desiredWidth = cd.left + cd.right + insets.left + insets.right;
+ double widthScale = Math.min(1.0, parent.getWidth()
+ / (double) desiredWidth);
+ double heightScale = Math.min(1.0, parent.getHeight()
+ / (double) cd.height);
+
+ double scale = Math.min(widthScale, heightScale);
+
+ // System.out.println("FormLayout.layoutContainer: widthScale = " +
+ // widthScale + "; heightScale = " + heightScale);
+
+ int midPt = (int) (((cd.left + insets.left + this.hGap) / (double) (cd.left
+ + cd.right + insets.left + insets.right + hGap)) * parent
+ .getWidth());
+ int top = insets.top + this.vGap;
+
+ int nComponents = parent.getComponentCount();
+ for (int i = 1; i < nComponents; i += 2) {
+ Component left = parent.getComponent(i - 1);
+ Component right = parent.getComponent(i);
+ Dimension lDim = left.getPreferredSize();
+ Dimension rDim = right.getPreferredSize();
+
+ int rowHeight = (int) (Math.max(lDim.height, rDim.height) * heightScale);
+
+ // scale left side, if necessary; then position
+ if (lDim.width > desiredWidth || lDim.height > rowHeight) {
+ lDim.width = (int) (lDim.width * scale);
+ lDim.height = (int) (lDim.height * scale);
+ }
+ left.setBounds((midPt - lDim.width - this.hGap / 2), top,
+ lDim.width, lDim.height);
+
+ // scale right side, if necessary; then position
+ if (rDim.width > desiredWidth || rDim.height > rowHeight) {
+ rDim.width = (int) (rDim.width * scale);
+ rDim.height = (int) (rDim.height * scale);
+ }
+ right.setBounds(midPt + this.hGap / 2, top, rDim.width,
+ rDim.height);
+ top = top + rowHeight + this.vGap;
+ }
+ if (nComponents % 2 == 1) { // odd number of components -- get the
+ // last one on the left
+ Component left = parent.getComponent(nComponents - 1);
+ Dimension lDim = left.getPreferredSize();
+ lDim.width = (int) (lDim.width * scale);
+ lDim.height = (int) (lDim.height * scale);
+ left.setBounds((midPt - lDim.width - this.hGap / 2), top,
+ lDim.width, lDim.height);
+ }
+ }
+ }
+
+ private static class ColDims {
+ int left = 0;
+ int right = 0;
+ int height = 0;
+ }
+}
+
+
+
+
+
diff --git a/java/2-6-Layout/LayoutDemo.java b/java/2-6-Layout/LayoutDemo.java
new file mode 100644
index 0000000..8db7dfc
--- /dev/null
+++ b/java/2-6-Layout/LayoutDemo.java
@@ -0,0 +1,351 @@
+
+import java.awt.BorderLayout;
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Container;
+import java.awt.Dimension;
+import java.awt.FlowLayout;
+import java.awt.GridBagConstraints;
+import java.awt.GridBagLayout;
+import java.awt.GridLayout;
+import javax.swing.SpringLayout;
+import java.awt.LayoutManager;
+
+import javax.swing.Box;
+import javax.swing.BoxLayout;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTextArea;
+import javax.swing.JTextField;
+
+/* Demonstrate various layout managers available in Java,
+ * including defining your own layout manager.
+ *
+ * @author Byron Weber Becker
+ */
+public class LayoutDemo {
+ public static void main(String[] args) {
+ // These are stacked bottom to top, so put the first one
+ // to be discussed last.
+ new LayoutFrame("RandomLayout", new DemoRandomLayout());
+ new LayoutFrame("SpringLayout", new DemoSpringLayout());
+ new LayoutFrame("GridBagLayout", new DemoGridBagLayout());
+ new LayoutFrame("BorderLayout", new DemoBorderLayout());
+ new LayoutFrame("BoxLayout3", new DemoBoxLayout3());
+ new LayoutFrame("BoxLayout2", new DemoBoxLayout2());
+ new LayoutFrame("BoxLayout1", new DemoBoxLayout1());
+ new LayoutFrame("GridLayout", new DemoGridLayout());
+ new LayoutFrame("FlowLayout", new DemoFlowLayout());
+ new LayoutFrame("NullLayout", new DemoNullLayout());
+ }
+}
+
+class LayoutFrame extends JFrame {
+ private static int xPos = 10;
+ private static int yPos = 10;
+ private static final int OFFSET = 50;
+
+ public LayoutFrame(String title, JPanel contents) {
+ super(title);
+ this.setContentPane(contents);
+ this.setSize(300, 130);
+ // set this to keep the JFrame from shrinking too small
+ //this.setMinimumSize(new Dimension(150, 100));
+ this.setLocation(xPos, yPos);
+ xPos += OFFSET;
+ yPos += OFFSET;
+ //this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+ this.setVisible(true);
+ }
+}
+
+
+// give positions and sizes for all widgets
+class DemoNullLayout extends JPanel {
+ public DemoNullLayout() {
+ this.setBackground(Color.DARK_GRAY);
+
+ // clear the layout
+ this.setLayout(null);
+
+ // Add the components
+ JButton b1 = new JButton("Button1");
+ JButton b2 = new JButton("Button2");
+ b1.setBounds(10, 20, 150, 50); // x, y, width, height
+ b2.setBounds(40, 60, 100, 30);
+ this.add(b2);
+ this.add(b1);
+ }
+}
+
+
+class DemoFlowLayout extends JPanel {
+ public DemoFlowLayout() {
+ this.setBackground(Color.DARK_GRAY);
+
+ // note also FlowLayout(int alignment, int horizontalSpace, int verticalSpace);
+ this.setLayout(new FlowLayout());
+
+ // Add the components
+ this.add(new JButton(" One "));
+ this.add(new JTextField(" Two ", 10));
+ this.add(new JButton(" Three "));
+ this.add(new JButton(" Four "));
+ }
+}
+
+
+class DemoGridLayout extends JPanel {
+ public DemoGridLayout() {
+ this.setBackground(Color.DARK_GRAY);
+
+ // Set the layout strategy to a grid with 2 rows and 3 columns.
+ this.setLayout(new GridLayout(2, 3));
+
+ // Add the components
+ // (always added in left-to-right, top-to-bottom reading order )
+ this.add(new JButton("One"));
+ this.add(new JButton("Two"));
+ this.add(new JButton("Three"));
+ this.add(new JButton("Four"));
+ this.add(new JButton("Five"));
+// this.add(new JButton("Six"));
+ }
+}
+
+
+class DemoBoxLayout1 extends JPanel {
+ // Default behaviour of BoxLayout
+ public DemoBoxLayout1() {
+ this.setBackground(Color.DARK_GRAY);
+
+ // use BoxLayout
+ // try BoxLayout.X_AXIS as well
+ this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
+
+ // Add the components
+ this.add(new JButton("One"));
+ this.add(new JButton("Two"));
+ this.add(new JTextArea("TextArea"));
+ this.add(new JButton("Three"));
+ }
+}
+
+class DemoBoxLayout2 extends JPanel {
+ public DemoBoxLayout2() {
+ this.setBackground(Color.DARK_GRAY);
+
+ // use BoxLayout
+ this.setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
+
+ // Add the components
+ this.add(new JButton("One"));
+ this.add(new JButton("Two"));
+ JTextArea ta = new JTextArea("TextArea");
+ // Text areas have infinite maximum size by default, so BoxLayout will
+ // grow it to fill all available space unless we place a limit.
+// ta.setMaximumSize(new Dimension(200, 150));
+ this.add(ta);
+ this.add(new JButton("Three"));
+ this.add(new JButton("Four"));
+ this.add(new JButton("Five"));
+ }
+}
+
+class DemoBoxLayout3 extends JPanel {
+ // Using rigid areas, struts and glue
+ public DemoBoxLayout3() {
+ this.setBackground(Color.DARK_GRAY);
+
+ // use BoxLayout
+ this.setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
+
+ // Add the components
+ this.add(new JButton("One"));
+ this.add(Box.createRigidArea(new Dimension(0,10)));
+ this.add(Box.createVerticalGlue());
+ this.add(new JButton("Two"));
+ this.add(Box.createVerticalStrut(10));
+ this.add(new JButton("Three"));
+ }
+}
+
+
+class DemoBorderLayout extends JPanel {
+ public DemoBorderLayout() {
+ this.setBackground(Color.DARK_GRAY);
+
+ // use BorderLayout
+ this.setLayout(new BorderLayout());
+
+ // Add the components
+ this.add(new JButton("North"), BorderLayout.NORTH);
+ this.add(new JButton("East"), BorderLayout.EAST);
+ this.add(new JButton("West"), BorderLayout.WEST);
+
+ // Layouts can be nested ...
+
+ // Box is an easy-to-create JPanel with a BoxLayout
+ Box b = Box.createHorizontalBox();
+ b.add(Box.createHorizontalGlue());
+ b.add(new JButton("Ok"));
+ b.add(Box.createHorizontalStrut(20));
+ b.add(new JButton("Cancel"));
+
+ this.add(b, BorderLayout.SOUTH);
+
+ // nesting a previous demo panel ...
+ this.add(new DemoBoxLayout1(), BorderLayout.CENTER);
+ }
+}
+
+
+
+class DemoGridBagLayout extends JPanel {
+ public DemoGridBagLayout() {
+ this.setBackground(Color.DARK_GRAY);
+
+ // use GridBagLayout
+ this.setLayout(new GridBagLayout());
+
+ // create a constraints object
+ GridBagConstraints gc = new GridBagConstraints();
+ // stretch the widget horizontally and vertically
+ gc.fill = GridBagConstraints.BOTH;
+ gc.gridwidth = 1; // 1 grid cell wide
+ gc.gridheight = 3; // 3 grid cells tall
+ gc.weightx = 0.5; // the proportion of space to give this column
+ gc.weighty = 0.5; // the proportion of space to give this row
+ this.add(new JButton("One"), gc);
+
+ // modify gc for the next widget to be added
+ gc.fill = GridBagConstraints.VERTICAL;
+ gc.gridwidth = 1;
+ gc.gridheight = 1;
+ gc.gridx = 1;
+ gc.gridy = 0;
+ gc.anchor = GridBagConstraints.WEST;
+ this.add(new JButton("Two"), gc);
+ gc.gridy = 1;
+ gc.anchor = GridBagConstraints.CENTER;
+ this.add(new JButton("Three"), gc);
+ gc.gridy = 2;
+ gc.anchor = GridBagConstraints.EAST;
+ this.add(new JButton("Four"), gc);
+ // add something spanning across the bottom
+ gc.fill = GridBagConstraints.HORIZONTAL;
+ gc.gridx = 0;
+ gc.gridy = 3;
+ gc.gridwidth = 2;
+ this.add(new JButton("Five"), gc);
+ }
+}
+
+class DemoSpringLayout extends JPanel {
+ private JButton b1 = new JButton("b1 - - - - ");
+ private JTextArea t1 = new JTextArea("t1");
+ private JButton b2 = new JButton("b2");
+
+ public DemoSpringLayout() {
+ this.setBackground(Color.DARK_GRAY);
+
+ // use SpringLayout
+ SpringLayout layout = new SpringLayout();
+ this.setLayout(layout);
+
+ this.add(this.b1);
+ this.add(this.t1);
+ this.add(this.b2);
+
+ // Add constraints to b1
+ // constrain west side of b1 to be 10 pixels from west side of the panel
+ layout.putConstraint(SpringLayout.WEST, b1, 10,
+ SpringLayout.WEST, this);
+ // constrain north side of b1 to be 10 pixels from north side of the panel
+ layout.putConstraint(SpringLayout.NORTH, b1, 10,
+ SpringLayout.NORTH, this);
+
+
+
+ // Add constraints to b2
+ // constrain b2 to stay 10 pixels from left of panel
+ layout.putConstraint(SpringLayout.WEST, b2, 10,
+ SpringLayout.WEST, this);
+ // constrain b2 to stay 10 pixels from bottom of panel
+ layout.putConstraint(SpringLayout.SOUTH, b2, -10,
+ SpringLayout.SOUTH, this);
+
+ // constrain east side of b2 to be east side of b1
+ layout.putConstraint(SpringLayout.EAST, b2, 0,
+ SpringLayout.EAST, b1);
+
+
+
+ // Add constraints to t1
+ // Let the textarea grow as large as requested
+ t1.setMaximumSize(new Dimension(Integer.MAX_VALUE,
+ Integer.MAX_VALUE));
+
+ // constrain t1 to be east of the buttons and spread vertically to fill
+ // the entire height of the panel
+ layout.putConstraint(SpringLayout.WEST, t1, 10,
+ SpringLayout.EAST, b1);
+ layout.putConstraint(SpringLayout.NORTH, t1, 10,
+ SpringLayout.NORTH, this);
+ layout.putConstraint(SpringLayout.SOUTH, t1, -10,
+ SpringLayout.SOUTH, this);
+ layout.putConstraint(SpringLayout.EAST, t1, -10,
+ SpringLayout.EAST, this );
+ }
+}
+
+
+class DemoRandomLayout extends JPanel {
+
+ public DemoRandomLayout() {
+ this.setBackground(Color.DARK_GRAY);
+
+ // use custom layout
+ this.setLayout(new RandomLayout());
+
+ this.add(new JButton("One"));
+ this.add(new JButton("Two"));
+ this.add(new JButton("Three"));
+ this.add(new JButton("Four"));
+ this.add(new JButton("Five"));
+ this.add(new JButton("Six"));
+
+ }
+}
+
+// a custom layout manager
+class RandomLayout implements LayoutManager {
+ public void addLayoutComponent(String name, Component comp) {
+ // no-op
+ }
+ public void layoutContainer(Container container) {
+ Component[] components = container.getComponents();
+ Dimension parentSize = container.getSize();
+
+ for (int i = 0; i < components.length; i++) {
+ Component c = components[i];
+ c.setSize(c.getPreferredSize());
+ int x = (int)(Math.random() * (parentSize.width - c.getWidth()));
+ int y = (int)(Math.random() * (parentSize.height - c.getHeight()));
+ c.setLocation(x, y);
+ }
+ }
+ public Dimension minimumLayoutSize(Container parent) {
+ return new Dimension(400, 300);
+ }
+ public Dimension preferredLayoutSize(Container parent) {
+ return this.minimumLayoutSize(parent);
+ }
+ public void removeLayoutComponent(Component comp) {
+ // no-op
+ }
+}
+
diff --git a/java/2-6-Layout/makefile b/java/2-6-Layout/makefile
new file mode 100644
index 0000000..c3be10b
--- /dev/null
+++ b/java/2-6-Layout/makefile
@@ -0,0 +1,15 @@
+# super simple makefile
+# call it using 'make NAME=name_of_code_file_without_extension'
+# (assumes a .java extension)
+NAME = "LayoutDemo"
+
+all:
+ @echo "Compiling..."
+ javac *.java
+
+run: all
+ @echo "Running..."
+ java $(NAME)
+
+clean:
+ rm -rf *.class
--
GitLab