JOGL v2.6.0-rc-20250706
JOGL, High-Performance Graphics Binding for Java™ (public API).
GridLayout.java
Go to the documentation of this file.
1/**
2 * Copyright 2023 JogAmp Community. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without modification, are
5 * permitted provided that the following conditions are met:
6 *
7 * 1. Redistributions of source code must retain the above copyright notice, this list of
8 * conditions and the following disclaimer.
9 *
10 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
11 * of conditions and the following disclaimer in the documentation and/or other materials
12 * provided with the distribution.
13 *
14 * THIS SOFTWARE IS PROVIDED BY JogAmp Community ``AS IS'' AND ANY EXPRESS OR IMPLIED
15 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
16 * FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JogAmp Community OR
17 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
19 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
20 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
21 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
22 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23 *
24 * The views and conclusions contained in the software and documentation are those of the
25 * authors and should not be interpreted as representing official policies, either expressed
26 * or implied, of JogAmp Community.
27 */
28package com.jogamp.graph.ui.layout;
29
30import java.util.List;
31
32import com.jogamp.graph.ui.Group;
33import com.jogamp.graph.ui.Shape;
34import com.jogamp.math.FloatUtil;
35import com.jogamp.math.Vec2f;
36import com.jogamp.math.Vec3f;
37import com.jogamp.math.geom.AABBox;
38import com.jogamp.math.util.PMVMatrix4f;
39
40/**
41 * GraphUI Grid {@link Group.Layout}.
42 * <p>
43 * A grid of {@link Shape}s
44 * <ul>
45 * <li>Optionally centered {@link Alignment.Bit#CenterHoriz horizontally}, {@link Alignment.Bit#CenterVert vertically} or {@link Alignment#Center both}.</li>
46 * <li>Optionally scaled to cell-size if given and {@link Alignment#Fill}</li>
47 * <li>Unscaled {@link Padding} is applied to each {@Shape} via {@link Shape#setPaddding(Padding)} if passed in constructor and is scaled if {@link Alignment.Bit#Fill}</li>
48 * <li>Without cell-size behaves like a grid bag using individual shape sizes including {@link Padding}</li>
49 * <li>Scaled {@link Gap} is applied unscaled if used.</li>
50 * <li>Can be filled in {@link Order#COLUMN} or {@link Order#ROW} major-order.</li>
51 * <li>Not implemented {@link Alignment}: {@link Alignment.Bit#Top Top}, {@link Alignment.Bit#Right Right}, {@link Alignment.Bit#Bottom Bottom}, {@link Alignment.Bit#Left Left}</li>
52 * <li>..</li>
53 * </ul>
54 * </p>
55 */
56public class GridLayout implements Group.Layout {
57 /** Layout order for {@link Group#getShapes()}} after population. */
58 public static enum Order {
59 /** COLUMN layout order of {@link Group#getShapes()}} is left to right and top to bottom. */
61 /** ROW layout order of {@link Group#getShapes()}} is top to bottom and left to right. */
62 ROW
63 }
64 private final Order order;
65 private final int col_limit;
66 private final int row_limit;
67 private final Vec2f cellSize;
68 private final Alignment alignment;
69 /** Scaled {@link Gap} value is applied w/o additional scaling. */
70 private final Gap gap;
71 /** Unscaled {@link Padding} value. */
72 private final Padding padding;
73 private int row_count, col_count;
74
75 private static final boolean TRACE_LAYOUT = false;
76
77 /**
78 * Default layout order of {@link Group#getShapes()}} is {@link Order#COLUMN}.
79 * @param column_limit [1..inf)
80 * @param cellWidth
81 * @param cellHeight
82 * @param alignment TODO
83 */
84 public GridLayout(final int column_limit, final float cellWidth, final float cellHeight, final Alignment alignment) {
85 this(alignment, Math.max(1, column_limit), -1, cellWidth, cellHeight, Gap.None, null);
86 }
87
88 /**
89 * Default layout order of {@link Group#getShapes()}} is {@link Order#COLUMN}.
90 * @param column_limit [1..inf)
91 * @param cellWidth
92 * @param cellHeight
93 * @param alignment TODO
94 * @param gap scaled {@link Gap} value is applied w/o additional scaling
95 */
96 public GridLayout(final int column_limit, final float cellWidth, final float cellHeight, final Alignment alignment, final Gap gap) {
97 this(alignment, Math.max(1, column_limit), -1, cellWidth, cellHeight, gap, null);
98 }
99
100 /**
101 * Default layout order of {@link Group#getShapes()}} is {@link Order#COLUMN}.
102 * @param column_limit [1..inf)
103 * @param cellWidth
104 * @param cellHeight
105 * @param alignment TODO
106 * @param gap scaled {@link Gap} value is applied w/o additional scaling
107 * @param padding unscaled {@link Padding} applied to each {@Shape} via {@link Shape#setPaddding(Padding)} and is scaled if {@link Alignment.Bit#Fill}
108 */
109 public GridLayout(final int column_limit, final float cellWidth, final float cellHeight, final Alignment alignment, final Gap gap, final Padding padding) {
110 this(alignment, Math.max(1, column_limit), -1, cellWidth, cellHeight, gap, padding);
111 }
112
113 /**
114 * Default layout order of {@link Group#getShapes()}} is {@link Order#ROW}.
115 * @param cellWidth
116 * @param cellHeight
117 * @param alignment TODO
118 * @param row_limit [1..inf)
119 */
120 public GridLayout(final float cellWidth, final float cellHeight, final Alignment alignment, final int row_limit) {
121 this(alignment, -1, Math.max(1, row_limit), cellWidth, cellHeight, Gap.None, null);
122 }
123
124 /**
125 * Default layout order of {@link Group#getShapes()}} is {@link Order#ROW}.
126 * @param cellWidth
127 * @param cellHeight
128 * @param alignment TODO
129 * @param gap scaled {@link Gap} value is applied w/o additional scaling
130 * @param row_limit [1..inf)
131 */
132 public GridLayout(final float cellWidth, final float cellHeight, final Alignment alignment, final Gap gap, final int row_limit) {
133 this(alignment, -1, Math.max(1, row_limit), cellWidth, cellHeight, gap, null);
134 }
135
136 /**
137 * Default layout order of {@link Group#getShapes()}} is {@link Order#ROW}.
138 * @param cellWidth
139 * @param cellHeight
140 * @param alignment TODO
141 * @param gap scaled {@link Gap} value is applied w/o additional scaling
142 * @param padding unscaled {@link Padding} applied to each {@Shape} via {@link Shape#setPaddding(Padding)} and is scaled if {@link Alignment.Bit#Fill}
143 * @param row_limit [1..inf)
144 */
145 public GridLayout(final float cellWidth, final float cellHeight, final Alignment alignment, final Gap gap, final Padding padding, final int row_limit) {
146 this(alignment, -1, Math.max(1, row_limit), cellWidth, cellHeight, gap, padding);
147 }
148
149 private GridLayout(final Alignment alignment, final int column_limit, final int row_limit, final float cellWidth, final float cellHeight,
150 final Gap gap, final Padding padding) {
151 this.order = 0 < column_limit ? Order.COLUMN : Order.ROW;
152 this.col_limit = column_limit;
153 this.row_limit = row_limit;
154 this.cellSize = new Vec2f(Math.max(0f, cellWidth), Math.max(0f, cellHeight));
155 this.alignment = alignment;
156 this.gap = gap;
157 this.padding = padding;
158 row_count = 0;
159 col_count = 0;
160 }
161
162 /** Returns given {@link Order}. */
163 public Order getOrder() { return order; }
164 /** Returns column count after {@link #layout(Group, AABBox, PMVMatrix4f)}. */
165 public int getColumnCount() { return col_count; }
166 /** Returns row count after {@link #layout(Group, AABBox, PMVMatrix4f)}. */
167 public int getRowCount() { return row_count; }
168 /** Returns the preset cell size */
169 public Vec2f getCellSize() { return cellSize; }
170 /** Returns given {@link Alignment}. */
171 public Alignment getAlignment() { return alignment; }
172 /** Returns given scaled {@link Gap}. */
173 public Gap getGap() { return gap; }
174 /** Returns given unscaled {@link Padding}, may be {@code null} if not given via constructor. */
175 public Padding getPadding() { return padding; }
176
177 @Override
178 public void preValidate(final Shape s) {
179 if( null != padding ) {
180 s.setPaddding(padding);
181 }
182 }
183
184 @Override
185 public void layout(final Group g, final AABBox box, final PMVMatrix4f pmv) {
186 final boolean hasCellWidth = !FloatUtil.isZero(cellSize.x());
187 final boolean hasCellHeight = !FloatUtil.isZero(cellSize.y());
188 final boolean isCenteredHoriz = hasCellWidth && alignment.isSet(Alignment.Bit.CenterHoriz);
189 final boolean isCenteredVert = hasCellHeight && alignment.isSet(Alignment.Bit.CenterVert);
190 final boolean isScaled = alignment.isSet(Alignment.Bit.Fill) && ( hasCellWidth || hasCellHeight );
191 final List<Shape> shapes = g.getShapes();
192 if( Order.COLUMN == order ) {
193 row_count = (int) Math.ceil( (double)shapes.size() / (double)col_limit );
194 col_count = col_limit;
195 } else { // Order.ROW_MAJOR == order
196 row_count = row_limit;
197 col_count = (int) Math.ceil( (double)shapes.size() / (double)row_limit );
198 }
199 if( TRACE_LAYOUT ) {
200 System.err.println("gl.00: "+order+", "+col_count+" x "+row_count+", a "+alignment+", shapes "+shapes.size()+", "+gap+", "+box);
201 }
202 int col_i = 0, row_i = 0;
203 float x=0, y=0;
204 float totalWidth=-Float.MAX_VALUE, totalHeight=-Float.MAX_VALUE;
205 final AABBox[] sboxes = new AABBox[shapes.size()];
206 final float[] y_pos = new float[col_count * row_count]; // y_bottom = totalHeight - y_pos[..]
207
208 // Pass-1: Determine totalHeight, while collect sbox and y_pos
209 for(int i=0; i < shapes.size(); ++i) {
210 final Shape s = shapes.get(i);
211 // measure size
212 pmv.pushMv();
213 s.applyMatToMv(pmv);
214 final AABBox sbox = s.getBounds().transform(pmv.getMv(), new AABBox());
215 pmv.popMv();
216
217 final float shapeWidthU = sbox.getWidth();
218 final float shapeHeightU = sbox.getHeight();
219 if( FloatUtil.isZero(shapeHeightU) || FloatUtil.isZero(shapeHeightU) ) {
220 continue;
221 }
222 sboxes[i] = sbox;
223 final float sxy;
224 if( isScaled ) {
225 // scaling to cell size
226 final float cellWidth = hasCellWidth ? cellSize.x() : shapeWidthU;
227 final float cellHeight = hasCellHeight ? cellSize.y() : shapeHeightU;
228 final float sx = cellWidth / shapeWidthU;
229 final float sy = cellHeight/ shapeHeightU;
230 sxy = sx < sy ? sx : sy;
231 } else {
232 sxy = 1;
233 }
234 final float shapeWidthS = sxy * shapeWidthU;
235 final float shapeHeightS = sxy * shapeHeightU;
236 final float cellWidthS = hasCellWidth ? cellSize.x() : shapeWidthS;
237 final float cellHeightS = hasCellHeight ? cellSize.y() : shapeHeightS;
238
239 // bottom y_pos, top to bottom, to be subtracted from totalHeight
240 final float y0 = y + cellHeightS;
241 final float x1 = x + cellWidthS;
242 totalHeight = Math.max(totalHeight, y0);
243 totalWidth = Math.max(totalWidth, x1);
244 y_pos[col_count * row_i + col_i] = y0;
245 if( TRACE_LAYOUT ) {
246 System.err.println("gl.00: y("+i+")["+col_i+"]["+row_i+"]: "+y0+", ["+cellWidthS+" x "+cellHeightS+"]");
247 }
248
249 // position for next cell
250 if( i + 1 < shapes.size() ) {
251 if( Order.COLUMN == order ) {
252 if( col_i + 1 == col_count ) {
253 col_i = 0;
254 row_i++;
255 x = 0;
256 y += cellHeightS + gap.height();
257 } else {
258 col_i++;
259 x += cellWidthS + gap.width();
260 }
261 } else { // Order.ROW_MAJOR == order
262 if( row_i + 1 == row_count ) {
263 row_i = 0;
264 col_i++;
265 y = 0;
266 x += cellWidthS + gap.width();
267 } else {
268 row_i++;
269 y += cellHeightS + gap.height();
270 }
271 }
272 }
273 }
274 if( TRACE_LAYOUT ) {
275 System.err.println("gl[__].00: Total "+totalWidth+" / "+totalHeight);
276 }
277
278 // Pass-2: Layout
279 row_i = 0; col_i = 0;
280 x = 0; y = 0;
281 for(int i=0; i < shapes.size(); ++i) {
282 final Shape s = shapes.get(i);
283 final AABBox sbox = sboxes[i];
284 if( null == sbox ) {
285 continue;
286 }
287 if( TRACE_LAYOUT ) {
288 System.err.println("gl("+i+")["+col_i+"]["+row_i+"].0: sbox "+sbox+", s "+s);
289 }
290
291 // IF isScaled: Uniform scale w/ lowest axis scale and center position on lower-scale axis
292 final float shapeWidthU = sbox.getWidth();
293 final float shapeHeightU = sbox.getHeight();
294 final float sxy;
295 float dxh = 0, dyh = 0;
296 if( isScaled ) {
297 // scaling to cell size
298 final float cellWidth = hasCellWidth ? cellSize.x() : shapeWidthU;
299 final float cellHeight = hasCellHeight ? cellSize.y() : shapeHeightU;
300 final float sx = cellWidth / shapeWidthU;
301 final float sy = cellHeight/ shapeHeightU;
302 sxy = sx < sy ? sx : sy;
303
304 if( TRACE_LAYOUT ) {
305 System.err.println("gl("+i+")["+col_i+"]["+row_i+"].s: "+sx+" x "+sy+" -> "+sxy+": +"+dxh+" / "+dyh+", U: s "+shapeWidthU+" x "+shapeHeightU+", sz "+cellWidth+" x "+cellHeight);
306 }
307 } else {
308 sxy = 1;
309 }
310 final float shapeWidthS = sxy * shapeWidthU;
311 final float shapeHeightS = sxy * shapeHeightU;
312 final float cellWidthS = hasCellWidth ? cellSize.x() : shapeWidthS;
313 final float cellHeightS = hasCellHeight ? cellSize.y() : shapeHeightS;
314
315 y = totalHeight - y_pos[col_count * row_i + col_i];
316
317 if( isCenteredHoriz ) {
318 dxh += 0.5f * ( cellWidthS - shapeWidthS ); // horiz-center
319 }
320 if( isCenteredVert ) {
321 dyh += 0.5f * ( cellHeightS - shapeHeightS ); // vert-center
322 }
323
324 if( TRACE_LAYOUT ) {
325 System.err.println("gl("+i+")["+col_i+"]["+row_i+"].m: "+x+" / "+y+" + "+dxh+" / "+dyh+", S: s "+shapeWidthS+" x "+shapeHeightS+", sz "+cellWidthS+" x "+cellHeightS);
326 }
327 // Position and scale shape
328 {
329 // New shape position, relative to previous position
330 final float aX = x + dxh;
331 final float aY = y + dyh;
332 s.moveTo( aX, aY, s.getPosition().z() );
333
334 // Remove the negative or positive delta on centered axis.
335 // Only remove negative offset of non-centered axis (i.e. underline)
336 final Vec3f diffBL = new Vec3f(s.getBounds().getLow());
337 diffBL.setZ(0);
338 if( isCenteredHoriz || isCenteredVert ) {
339 if( !isCenteredVert && diffBL.y() > 0 ) {
340 diffBL.setY(0); // only adjust negative if !center-vert
341 } else if( !isCenteredHoriz && diffBL.x() > 0 ) {
342 diffBL.setX(0); // only adjust negative if !center-horiz
343 }
344 diffBL.mul(s.getScale()).scale(-1f);
345 } else {
346 diffBL.min(new Vec3f()).mul(s.getScale()).scale(-1f);
347 }
348 s.move( diffBL.scale(sxy) );
349 if( TRACE_LAYOUT ) {
350 System.err.println("gl("+i+")["+col_i+"]["+row_i+"].bl: sbox0 "+s.getBounds()+", diffBL_ "+diffBL);
351 }
352
353 // resize bounds
354 box.resize( x, y, sbox.getMinZ());
355 box.resize( x + cellWidthS, y + cellHeightS, sbox.getMaxZ());
356 }
357 s.scale( sxy, sxy, 1f);
358
359 if( TRACE_LAYOUT ) {
360 System.err.println("gl("+i+")["+col_i+"]["+row_i+"].x: "+x+" / "+y+" + "+dxh+" / "+dyh+" -> "+s.getPosition()+", p3 "+shapeWidthS+" x "+shapeHeightS+", sz3 "+cellWidthS+" x "+cellHeightS+", box "+box.getWidth()+" x "+box.getHeight());
361 System.err.println("gl("+i+")["+col_i+"]["+row_i+"].x: "+s);
362 System.err.println("gl("+i+")["+col_i+"]["+row_i+"].x: "+box);
363 }
364
365 if( i + 1 < shapes.size() ) {
366 // position for next cell
367 if( Order.COLUMN == order ) {
368 if( col_i + 1 == col_count ) {
369 col_i = 0;
370 row_i++;
371 x = 0;
372 } else {
373 col_i++;
374 x += cellWidthS + gap.width();
375 }
376 } else { // Order.ROW_MAJOR == order
377 if( row_i + 1 == row_count ) {
378 row_i = 0;
379 col_i++;
380 y = 0;
381 x += cellWidthS + gap.width();
382 } else {
383 row_i++;
384 }
385 }
386 }
387 }
388 if( Float.isInfinite(box.getWidth()) || Float.isInfinite(box.getHeight()) ) {
389 box.resize(0, 0, 0);
390 }
391 if( TRACE_LAYOUT ) {
392 System.err.println("gl.xx: "+box);
393 }
394 }
395
396 @Override
397 public String toString() {
398 final String p_s = ( null == padding || padding.zeroSize() ) ? "" : ", "+padding.toString();
399 final String g_s = gap.zeroSumSize() ? "" : ", "+gap.toString();
400 return "Grid["+col_count+"x"+row_count+", "+order+", cell "+cellSize+", a "+alignment+g_s+p_s+"]";
401 }
402}
403
Group of Shapes, optionally utilizing a Group.Layout.
Definition: Group.java:61
List< Shape > getShapes()
Returns added Shapes.
Definition: Group.java:219
Generic Shape, potentially using a Graph via GraphShape or other means of representing content.
Definition: Shape.java:87
final Shape move(final float dtx, final float dty, final float dtz)
Move about scaled distance.
Definition: Shape.java:557
final Vec3f getScale()
Returns scale Vec3f reference.
Definition: Shape.java:682
final Shape moveTo(final float tx, final float ty, final float tz)
Move to scaled position.
Definition: Shape.java:543
final Vec3f getPosition()
Returns position Vec3f reference, i.e.
Definition: Shape.java:587
final AABBox getBounds()
Returns the unscaled bounding AABBox for this shape, borrowing internal instance.
Definition: Shape.java:732
final Shape setPaddding(final Padding padding)
Sets the unscaled padding for this shape, which is included in unscaled getBounds() and also includes...
Definition: Shape.java:376
final void applyMatToMv(final PMVMatrix4f pmv)
Applies the internal Matrix4f to the given modelview matrix, i.e.
Definition: Shape.java:908
Immutable layout alignment options, including Bit#Fill.
Definition: Alignment.java:35
boolean isSet(final Bit bit)
Definition: Alignment.java:94
GraphUI CSS property Gap, scaled spacing between (grid) cells not belonging to the cell element.
Definition: Gap.java:38
static final Gap None
Zero gap constant.
Definition: Gap.java:40
float height()
Return scaled height of vertical value, i.e.
Definition: Gap.java:72
float width()
Return scaled width of horizontal value, i.e.
Definition: Gap.java:69
GraphUI Grid Group.Layout.
Definition: GridLayout.java:56
GridLayout(final int column_limit, final float cellWidth, final float cellHeight, final Alignment alignment, final Gap gap)
Default layout order of Group#getShapes()} is Order#COLUMN.
Definition: GridLayout.java:96
Vec2f getCellSize()
Returns the preset cell size.
int getColumnCount()
Returns column count after layout(Group, AABBox, PMVMatrix4f).
Order getOrder()
Returns given Order.
void preValidate(final Shape s)
Prepare given Shape before validation, e.g.
GridLayout(final float cellWidth, final float cellHeight, final Alignment alignment, final Gap gap, final Padding padding, final int row_limit)
Default layout order of Group#getShapes()} is Order#ROW.
GridLayout(final int column_limit, final float cellWidth, final float cellHeight, final Alignment alignment)
Default layout order of Group#getShapes()} is Order#COLUMN.
Definition: GridLayout.java:84
GridLayout(final float cellWidth, final float cellHeight, final Alignment alignment, final int row_limit)
Default layout order of Group#getShapes()} is Order#ROW.
Padding getPadding()
Returns given unscaled Padding, may be null if not given via constructor.
GridLayout(final int column_limit, final float cellWidth, final float cellHeight, final Alignment alignment, final Gap gap, final Padding padding)
Default layout order of Group#getShapes()} is Order#COLUMN.
void layout(final Group g, final AABBox box, final PMVMatrix4f pmv)
Performing the layout of Group#getShapes(), called @ Shape#validate(GL2ES2) or Shape#validate(GLProfi...
Gap getGap()
Returns given scaled Gap.
Alignment getAlignment()
Returns given Alignment.
int getRowCount()
Returns row count after layout(Group, AABBox, PMVMatrix4f).
GridLayout(final float cellWidth, final float cellHeight, final Alignment alignment, final Gap gap, final int row_limit)
Default layout order of Group#getShapes()} is Order#ROW.
GraphUI CSS property Padding, unscaled space belonging to the element and included in the element's s...
Definition: Padding.java:38
Basic Float math utility functions.
Definition: FloatUtil.java:83
static boolean isZero(final float a, final float epsilon)
Returns true if value is zero, i.e.
2D Vector based upon two float components.
Definition: Vec2f.java:37
3D Vector based upon three float components.
Definition: Vec3f.java:37
Vec3f mul(final float val)
Returns this * val; creates new vector.
Definition: Vec3f.java:178
void setX(final float x)
Definition: Vec3f.java:158
Vec3f scale(final float s)
this = this * s, returns this.
Definition: Vec3f.java:218
void setZ(final float z)
Definition: Vec3f.java:160
void setY(final float y)
Definition: Vec3f.java:159
Vec3f min(final Vec3f m)
this = min(this, m), returns this.
Definition: Vec3f.java:170
Axis Aligned Bounding Box.
Definition: AABBox.java:54
final float getWidth()
Definition: AABBox.java:879
final Vec3f getLow()
Returns the minimum left-bottom-far (xyz) coordinate.
Definition: AABBox.java:140
final float getHeight()
Definition: AABBox.java:883
AABBox transform(final Matrix4f mat, final AABBox out)
Transform this box using the given Matrix4f into out @endiliteral.
Definition: AABBox.java:933
final AABBox resize(final AABBox newBox)
Resize the AABBox to encapsulate another AABox.
Definition: AABBox.java:274
PMVMatrix4f implements the basic computer graphics Matrix4f pack using projection (P),...
final Matrix4f getMv()
Returns the modelview matrix (Mv).
final PMVMatrix4f popMv()
Pop the modelview matrix from its stack.
final PMVMatrix4f pushMv()
Push the modelview matrix to its stack, while preserving its values.
CenterHoriz
Horizontal center alignment.
Definition: Alignment.java:64
CenterVert
Vertical center alignment.
Definition: Alignment.java:67
Fill
Scale object to parent size, e.g.
Definition: Alignment.java:61
Layout order for Group#getShapes()} after population.
Definition: GridLayout.java:58
COLUMN
COLUMN layout order of Group#getShapes()} is left to right and top to bottom.
Definition: GridLayout.java:60
Layout for the GraphUI Group, called @ Shape#validate(GL2ES2) or Shape#validate(GLProfile).
Definition: Group.java:63