001 /* ========================================================================
002 * JCommon : a free general purpose class library for the Java(tm) platform
003 * ========================================================================
004 *
005 * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
006 *
007 * Project Info: http://www.jfree.org/jcommon/index.html
008 *
009 * This library is free software; you can redistribute it and/or modify it
010 * under the terms of the GNU Lesser General Public License as published by
011 * the Free Software Foundation; either version 2.1 of the License, or
012 * (at your option) any later version.
013 *
014 * This library is distributed in the hope that it will be useful, but
015 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
016 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
017 * License for more details.
018 *
019 * You should have received a copy of the GNU Lesser General Public
020 * License along with this library; if not, write to the Free Software
021 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
022 * USA.
023 *
024 * [Java is a trademark or registered trademark of Sun Microsystems, Inc.
025 * in the United States and other countries.]
026 *
027 * -----------------
028 * FormatLayout.java
029 * -----------------
030 * (C) Copyright 2000-2005, by Object Refinery Limited.
031 *
032 * Original Author: David Gilbert (for Object Refinery Limited);
033 * Contributor(s): -;
034 *
035 * $Id: FormatLayout.java,v 1.4 2005/10/18 13:16:50 mungady Exp $
036 *
037 * Changes (from 26-Oct-2001)
038 * --------------------------
039 * 26-Oct-2001 : Changed package to com.jrefinery.layout.* (DG);
040 * 26-Jun-2002 : Removed redundant code (DG);
041 * 10-Oct-2002 : Fixed errors reported by Checkstyle (DG);
042 *
043 */
044
045 package org.jfree.layout;
046
047 import java.awt.Component;
048 import java.awt.Container;
049 import java.awt.Dimension;
050 import java.awt.Insets;
051 import java.awt.LayoutManager;
052 import java.io.Serializable;
053
054 /**
055 * A layout manager that spaces components over six columns in seven different
056 * formats.
057 *
058 * @author David Gilbert
059 */
060 public class FormatLayout implements LayoutManager, Serializable {
061
062 /** For serialization. */
063 private static final long serialVersionUID = 2866692886323930722L;
064
065 /** A useful constant representing layout format 1. */
066 public static final int C = 1;
067
068 /** A useful constant representing layout format 2. */
069 public static final int LC = 2;
070
071 /** A useful constant representing layout format 3. */
072 public static final int LCB = 3;
073
074 /** A useful constant representing layout format 4. */
075 public static final int LCLC = 4;
076
077 /** A useful constant representing layout format 5. */
078 public static final int LCLCB = 5;
079
080 /** A useful constant representing layout format 6. */
081 public static final int LCBLC = 6;
082
083 /** A useful constant representing layout format 7. */
084 public static final int LCBLCB = 7;
085
086 /** The layout format for each row. */
087 private int[] rowFormats;
088
089 /** The gap between the rows. */
090 private int rowGap;
091
092 /**
093 * The gaps between the columns (gap[0] is the gap following column zero).
094 */
095 private int[] columnGaps;
096
097 /** Working array for recording the height of each row. */
098 private int[] rowHeights;
099
100 /** The total height of the layout. */
101 private int totalHeight;
102
103 /** Working array for recording the width of each column. */
104 private int[] columnWidths;
105
106 /** The total width of the layout. */
107 private int totalWidth;
108
109 /** Combined width of columns 1 and 2. */
110 private int columns1and2Width;
111
112 /** Combined width of columns 4 and 5. */
113 private int columns4and5Width;
114
115 /** Combined width of columns 1 to 4. */
116 private int columns1to4Width;
117
118 /** Combined width of columns 1 to 5. */
119 private int columns1to5Width;
120
121 /** Combined width of columns 0 to 5. */
122 private int columns0to5Width;
123
124 /**
125 * Constructs a new layout manager that can be used to create input forms.
126 * The layout manager works by arranging components in rows using six
127 * columns (some components will use more than one column).
128 * <P>
129 * Any component can be added, but I think of them in terms of Labels,
130 * Components, and Buttons.
131 * The formats available are: C, LC, LCB, LCLC, LCLCB, LCBLC or LCBLCB.
132 * <table>
133 * <tr>
134 * <td>C</td>
135 * <td>1 component in this row (spread across all six columns).</td>
136 * </tr>
137 * <tr>
138 * <td>LC</td>
139 * <td>2 components, a label in the 1st column, and a component using the
140 * remaining 5 columns).</td>
141 * </tr>
142 * <tr>
143 * <td>LCB</td>
144 * <td>3 components, a label in the 1st column, a component spread across
145 * the next 4, and a button in the last column.</td>
146 * </tr>
147 * <tr>
148 * <td>LCLC</td>
149 * <td>4 components, a label in column 1, a component in 2-3, a label in
150 * 4 and a component in 5-6.</td>
151 * </tr>
152 * <tr>
153 * <td>LCLCB</td>
154 * <td>5 components, a label in column 1, a component in 2-3, a label
155 * in 4, a component in 5 and a button in 6.</td>
156 * </tr>
157 * <tr>
158 * <td>LCBLC</td>
159 * <td>5 components, a label in column 1, a component in 2, a button in 3,
160 * a label in 4, a component in 5-6.</td>
161 * </tr>
162 * <tr>
163 * <td>LCBLCB</td>
164 * <td>6 components, one in each column.</td>
165 * </tr>
166 * </table>
167 * <P>
168 * Columns 1 and 4 expand to accommodate the widest label, and 3 and 6 to
169 * accommodate the widest button.
170 * <P>
171 * Each row will contain the number of components indicated by the format.
172 * Be sure to specify enough row formats to cover all the components you
173 * add to the layout.
174 *
175 * @param rowCount the number of rows.
176 * @param rowFormats the row formats.
177 */
178 public FormatLayout(final int rowCount, final int[] rowFormats) {
179
180 this.rowFormats = rowFormats;
181 this.rowGap = 2;
182 this.columnGaps = new int[5];
183 this.columnGaps[0] = 10;
184 this.columnGaps[1] = 5;
185 this.columnGaps[2] = 5;
186 this.columnGaps[3] = 10;
187 this.columnGaps[4] = 5;
188
189 // working structures...
190 this.rowHeights = new int[rowCount];
191 this.columnWidths = new int[6];
192 }
193
194 /**
195 * Returns the preferred size of the component using this layout manager.
196 *
197 * @param parent the parent.
198 *
199 * @return the preferred size of the component.
200 */
201 public Dimension preferredLayoutSize(final Container parent) {
202
203 Component c0, c1, c2, c3, c4, c5;
204
205 synchronized (parent.getTreeLock()) {
206 final Insets insets = parent.getInsets();
207 int componentIndex = 0;
208 final int rowCount = this.rowHeights.length;
209 for (int i = 0; i < this.columnWidths.length; i++) {
210 this.columnWidths[i] = 0;
211 }
212 this.columns1and2Width = 0;
213 this.columns4and5Width = 0;
214 this.columns1to4Width = 0;
215 this.columns1to5Width = 0;
216 this.columns0to5Width = 0;
217
218 this.totalHeight = 0;
219 for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
220 final int format
221 = this.rowFormats[rowIndex % this.rowFormats.length];
222 switch (format) {
223 case FormatLayout.C:
224 c0 = parent.getComponent(componentIndex);
225 updateC(rowIndex, c0.getPreferredSize());
226 componentIndex = componentIndex + 1;
227 break;
228 case FormatLayout.LC:
229 c0 = parent.getComponent(componentIndex);
230 c1 = parent.getComponent(componentIndex + 1);
231 updateLC(rowIndex, c0.getPreferredSize(),
232 c1.getPreferredSize());
233 componentIndex = componentIndex + 2;
234 break;
235 case FormatLayout.LCB:
236 c0 = parent.getComponent(componentIndex);
237 c1 = parent.getComponent(componentIndex + 1);
238 c2 = parent.getComponent(componentIndex + 2);
239 updateLCB(rowIndex,
240 c0.getPreferredSize(),
241 c1.getPreferredSize(),
242 c2.getPreferredSize());
243 componentIndex = componentIndex + 3;
244 break;
245 case FormatLayout.LCLC:
246 c0 = parent.getComponent(componentIndex);
247 c1 = parent.getComponent(componentIndex + 1);
248 c2 = parent.getComponent(componentIndex + 2);
249 c3 = parent.getComponent(componentIndex + 3);
250 updateLCLC(rowIndex,
251 c0.getPreferredSize(),
252 c1.getPreferredSize(),
253 c2.getPreferredSize(),
254 c3.getPreferredSize());
255 componentIndex = componentIndex + 4;
256 break;
257 case FormatLayout.LCBLC:
258 c0 = parent.getComponent(componentIndex);
259 c1 = parent.getComponent(componentIndex + 1);
260 c2 = parent.getComponent(componentIndex + 2);
261 c3 = parent.getComponent(componentIndex + 3);
262 c4 = parent.getComponent(componentIndex + 4);
263 updateLCBLC(rowIndex,
264 c0.getPreferredSize(),
265 c1.getPreferredSize(),
266 c2.getPreferredSize(),
267 c3.getPreferredSize(),
268 c4.getPreferredSize());
269 componentIndex = componentIndex + 5;
270 break;
271 case FormatLayout.LCLCB:
272 c0 = parent.getComponent(componentIndex);
273 c1 = parent.getComponent(componentIndex + 1);
274 c2 = parent.getComponent(componentIndex + 2);
275 c3 = parent.getComponent(componentIndex + 3);
276 c4 = parent.getComponent(componentIndex + 4);
277 updateLCLCB(rowIndex,
278 c0.getPreferredSize(),
279 c1.getPreferredSize(),
280 c2.getPreferredSize(),
281 c3.getPreferredSize(),
282 c4.getPreferredSize());
283 componentIndex = componentIndex + 5;
284 break;
285 case FormatLayout.LCBLCB:
286 c0 = parent.getComponent(componentIndex);
287 c1 = parent.getComponent(componentIndex + 1);
288 c2 = parent.getComponent(componentIndex + 2);
289 c3 = parent.getComponent(componentIndex + 3);
290 c4 = parent.getComponent(componentIndex + 4);
291 c5 = parent.getComponent(componentIndex + 5);
292 updateLCBLCB(rowIndex,
293 c0.getPreferredSize(),
294 c1.getPreferredSize(),
295 c2.getPreferredSize(),
296 c3.getPreferredSize(),
297 c4.getPreferredSize(),
298 c5.getPreferredSize());
299 componentIndex = componentIndex + 6;
300 break;
301 }
302 }
303 complete();
304 return new Dimension(this.totalWidth + insets.left + insets.right,
305 this.totalHeight + (rowCount - 1) * this.rowGap
306 + insets.top + insets.bottom);
307 }
308 }
309
310 /**
311 * Returns the minimum size of the component using this layout manager.
312 *
313 * @param parent the parent.
314 *
315 * @return the minimum size of the component
316 */
317 public Dimension minimumLayoutSize(final Container parent) {
318
319 Component c0, c1, c2, c3, c4, c5;
320
321 synchronized (parent.getTreeLock()) {
322 final Insets insets = parent.getInsets();
323 int componentIndex = 0;
324 final int rowCount = this.rowHeights.length;
325 for (int i = 0; i < this.columnWidths.length; i++) {
326 this.columnWidths[i] = 0;
327 }
328 this.columns1and2Width = 0;
329 this.columns4and5Width = 0;
330 this.columns1to4Width = 0;
331 this.columns1to5Width = 0;
332 this.columns0to5Width = 0;
333 final int totalHeight = 0;
334 for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
335
336 final int format
337 = this.rowFormats[rowIndex % this.rowFormats.length];
338
339 switch (format) {
340 case FormatLayout.C:
341 c0 = parent.getComponent(componentIndex);
342 this.columns0to5Width = Math.max(
343 this.columns0to5Width, c0.getMinimumSize().width
344 );
345 componentIndex = componentIndex + 1;
346 break;
347 case FormatLayout.LC:
348 c0 = parent.getComponent(componentIndex);
349 c1 = parent.getComponent(componentIndex + 1);
350 updateLC(rowIndex,
351 c0.getMinimumSize(),
352 c1.getMinimumSize());
353 componentIndex = componentIndex + 2;
354 break;
355 case FormatLayout.LCB:
356 c0 = parent.getComponent(componentIndex);
357 c1 = parent.getComponent(componentIndex + 1);
358 c2 = parent.getComponent(componentIndex + 2);
359 updateLCB(rowIndex,
360 c0.getMinimumSize(),
361 c1.getMinimumSize(),
362 c2.getMinimumSize());
363 componentIndex = componentIndex + 3;
364 break;
365 case FormatLayout.LCLC:
366 c0 = parent.getComponent(componentIndex);
367 c1 = parent.getComponent(componentIndex + 1);
368 c2 = parent.getComponent(componentIndex + 2);
369 c3 = parent.getComponent(componentIndex + 3);
370 updateLCLC(rowIndex,
371 c0.getMinimumSize(),
372 c1.getMinimumSize(),
373 c2.getMinimumSize(),
374 c3.getMinimumSize());
375 componentIndex = componentIndex + 3;
376 break;
377 case FormatLayout.LCBLC:
378 c0 = parent.getComponent(componentIndex);
379 c1 = parent.getComponent(componentIndex + 1);
380 c2 = parent.getComponent(componentIndex + 2);
381 c3 = parent.getComponent(componentIndex + 3);
382 c4 = parent.getComponent(componentIndex + 4);
383 updateLCBLC(rowIndex,
384 c0.getMinimumSize(),
385 c1.getMinimumSize(),
386 c2.getMinimumSize(),
387 c3.getMinimumSize(),
388 c4.getMinimumSize());
389 componentIndex = componentIndex + 4;
390 break;
391 case FormatLayout.LCLCB:
392 c0 = parent.getComponent(componentIndex);
393 c1 = parent.getComponent(componentIndex + 1);
394 c2 = parent.getComponent(componentIndex + 2);
395 c3 = parent.getComponent(componentIndex + 3);
396 c4 = parent.getComponent(componentIndex + 4);
397 updateLCLCB(rowIndex,
398 c0.getMinimumSize(),
399 c1.getMinimumSize(),
400 c2.getMinimumSize(),
401 c3.getMinimumSize(),
402 c4.getMinimumSize());
403 componentIndex = componentIndex + 4;
404 break;
405 case FormatLayout.LCBLCB:
406 c0 = parent.getComponent(componentIndex);
407 c1 = parent.getComponent(componentIndex + 1);
408 c2 = parent.getComponent(componentIndex + 2);
409 c3 = parent.getComponent(componentIndex + 3);
410 c4 = parent.getComponent(componentIndex + 4);
411 c5 = parent.getComponent(componentIndex + 5);
412 updateLCBLCB(rowIndex,
413 c0.getMinimumSize(),
414 c1.getMinimumSize(),
415 c2.getMinimumSize(),
416 c3.getMinimumSize(),
417 c4.getMinimumSize(),
418 c5.getMinimumSize());
419 componentIndex = componentIndex + 5;
420 break;
421 }
422 }
423 complete();
424 return new Dimension(this.totalWidth + insets.left + insets.right,
425 totalHeight + (rowCount - 1) * this.rowGap
426 + insets.top + insets.bottom);
427 }
428 }
429
430 /**
431 * Performs the layout of the container.
432 *
433 * @param parent the parent.
434 */
435 public void layoutContainer(final Container parent) {
436 Component c0, c1, c2, c3, c4, c5;
437
438 synchronized (parent.getTreeLock()) {
439 final Insets insets = parent.getInsets();
440 int componentIndex = 0;
441 final int rowCount = this.rowHeights.length;
442 for (int i = 0; i < this.columnWidths.length; i++) {
443 this.columnWidths[i] = 0;
444 }
445 this.columns1and2Width = 0;
446 this.columns4and5Width = 0;
447 this.columns1to4Width = 0;
448 this.columns1to5Width = 0;
449 this.columns0to5Width
450 = parent.getBounds().width - insets.left - insets.right;
451
452 this.totalHeight = 0;
453 for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
454 final int format
455 = this.rowFormats[rowIndex % this.rowFormats.length];
456 switch (format) {
457 case FormatLayout.C:
458 c0 = parent.getComponent(componentIndex);
459 updateC(rowIndex, c0.getPreferredSize());
460 componentIndex = componentIndex + 1;
461 break;
462 case FormatLayout.LC:
463 c0 = parent.getComponent(componentIndex);
464 c1 = parent.getComponent(componentIndex + 1);
465 updateLC(rowIndex, c0.getPreferredSize(),
466 c1.getPreferredSize());
467 componentIndex = componentIndex + 2;
468 break;
469 case FormatLayout.LCB:
470 c0 = parent.getComponent(componentIndex);
471 c1 = parent.getComponent(componentIndex + 1);
472 c2 = parent.getComponent(componentIndex + 2);
473 updateLCB(rowIndex,
474 c0.getPreferredSize(),
475 c1.getPreferredSize(),
476 c2.getPreferredSize());
477 componentIndex = componentIndex + 3;
478 break;
479 case FormatLayout.LCLC:
480 c0 = parent.getComponent(componentIndex);
481 c1 = parent.getComponent(componentIndex + 1);
482 c2 = parent.getComponent(componentIndex + 2);
483 c3 = parent.getComponent(componentIndex + 3);
484 updateLCLC(rowIndex,
485 c0.getPreferredSize(),
486 c1.getPreferredSize(),
487 c2.getPreferredSize(),
488 c3.getPreferredSize());
489 componentIndex = componentIndex + 4;
490 break;
491 case FormatLayout.LCBLC:
492 c0 = parent.getComponent(componentIndex);
493 c1 = parent.getComponent(componentIndex + 1);
494 c2 = parent.getComponent(componentIndex + 2);
495 c3 = parent.getComponent(componentIndex + 3);
496 c4 = parent.getComponent(componentIndex + 4);
497 updateLCBLC(rowIndex,
498 c0.getPreferredSize(),
499 c1.getPreferredSize(),
500 c2.getPreferredSize(),
501 c3.getPreferredSize(),
502 c4.getPreferredSize());
503 componentIndex = componentIndex + 5;
504 break;
505 case FormatLayout.LCLCB:
506 c0 = parent.getComponent(componentIndex);
507 c1 = parent.getComponent(componentIndex + 1);
508 c2 = parent.getComponent(componentIndex + 2);
509 c3 = parent.getComponent(componentIndex + 3);
510 c4 = parent.getComponent(componentIndex + 4);
511 updateLCLCB(rowIndex,
512 c0.getPreferredSize(),
513 c1.getPreferredSize(),
514 c2.getPreferredSize(),
515 c3.getPreferredSize(),
516 c4.getPreferredSize());
517 componentIndex = componentIndex + 5;
518 break;
519 case FormatLayout.LCBLCB:
520 c0 = parent.getComponent(componentIndex);
521 c1 = parent.getComponent(componentIndex + 1);
522 c2 = parent.getComponent(componentIndex + 2);
523 c3 = parent.getComponent(componentIndex + 3);
524 c4 = parent.getComponent(componentIndex + 4);
525 c5 = parent.getComponent(componentIndex + 5);
526 updateLCBLCB(rowIndex,
527 c0.getPreferredSize(),
528 c1.getPreferredSize(),
529 c2.getPreferredSize(),
530 c3.getPreferredSize(),
531 c4.getPreferredSize(),
532 c5.getPreferredSize());
533 componentIndex = componentIndex + 6;
534 break;
535 }
536 }
537 complete();
538
539 componentIndex = 0;
540 int rowY = insets.top;
541 final int[] rowX = new int[6];
542 rowX[0] = insets.left;
543 rowX[1] = rowX[0] + this.columnWidths[0] + this.columnGaps[0];
544 rowX[2] = rowX[1] + this.columnWidths[1] + this.columnGaps[1];
545 rowX[3] = rowX[2] + this.columnWidths[2] + this.columnGaps[2];
546 rowX[4] = rowX[3] + this.columnWidths[3] + this.columnGaps[3];
547 rowX[5] = rowX[4] + this.columnWidths[4] + this.columnGaps[4];
548 final int w1to2 = this.columnWidths[1] + this.columnGaps[1]
549 + this.columnWidths[2];
550 final int w4to5 = this.columnWidths[4] + this.columnGaps[4]
551 + this.columnWidths[5];
552 final int w1to4 = w1to2 + this.columnGaps[2] + this.columnWidths[3]
553 + this.columnGaps[3] + this.columnWidths[4];
554 final int w1to5 = w1to4 + this.columnGaps[4] + this.columnWidths[5];
555 final int w0to5 = w1to5 + this.columnWidths[0] + this.columnGaps[0];
556 for (int rowIndex = 0; rowIndex < rowCount; rowIndex++) {
557 final int format
558 = this.rowFormats[rowIndex % this.rowFormats.length];
559
560 switch (format) {
561 case FormatLayout.C:
562 c0 = parent.getComponent(componentIndex);
563 c0.setBounds(rowX[0], rowY, w0to5,
564 c0.getPreferredSize().height);
565 componentIndex = componentIndex + 1;
566 break;
567 case FormatLayout.LC:
568 c0 = parent.getComponent(componentIndex);
569 c0.setBounds(
570 rowX[0],
571 rowY + (this.rowHeights[rowIndex]
572 - c0.getPreferredSize().height) / 2,
573 this.columnWidths[0], c0.getPreferredSize().height
574 );
575 c1 = parent.getComponent(componentIndex + 1);
576 c1.setBounds(
577 rowX[1],
578 rowY + (this.rowHeights[rowIndex]
579 - c1.getPreferredSize().height) / 2,
580 w1to5, c1.getPreferredSize().height
581 );
582 componentIndex = componentIndex + 2;
583 break;
584 case FormatLayout.LCB:
585 c0 = parent.getComponent(componentIndex);
586 c0.setBounds(
587 rowX[0],
588 rowY + (this.rowHeights[rowIndex]
589 - c0.getPreferredSize().height) / 2,
590 this.columnWidths[0], c0.getPreferredSize().height
591 );
592 c1 = parent.getComponent(componentIndex + 1);
593 c1.setBounds(
594 rowX[1],
595 rowY + (this.rowHeights[rowIndex]
596 - c1.getPreferredSize().height) / 2,
597 w1to4, c1.getPreferredSize().height
598 );
599 c2 = parent.getComponent(componentIndex + 2);
600 c2.setBounds(
601 rowX[5],
602 rowY + (this.rowHeights[rowIndex]
603 - c2.getPreferredSize().height) / 2,
604 this.columnWidths[5], c2.getPreferredSize().height
605 );
606 componentIndex = componentIndex + 3;
607 break;
608 case FormatLayout.LCLC:
609 c0 = parent.getComponent(componentIndex);
610 c0.setBounds(
611 rowX[0],
612 rowY + (this.rowHeights[rowIndex]
613 - c0.getPreferredSize().height) / 2,
614 this.columnWidths[0], c0.getPreferredSize().height
615 );
616 c1 = parent.getComponent(componentIndex + 1);
617 c1.setBounds(
618 rowX[1],
619 rowY + (this.rowHeights[rowIndex]
620 - c1.getPreferredSize().height) / 2,
621 w1to2, c1.getPreferredSize().height
622 );
623 c2 = parent.getComponent(componentIndex + 2);
624 c2.setBounds(
625 rowX[3],
626 rowY + (this.rowHeights[rowIndex]
627 - c2.getPreferredSize().height) / 2,
628 this.columnWidths[3], c2.getPreferredSize().height
629 );
630 c3 = parent.getComponent(componentIndex + 3);
631 c3.setBounds(
632 rowX[4],
633 rowY + (this.rowHeights[rowIndex]
634 - c3.getPreferredSize().height) / 2,
635 w4to5, c3.getPreferredSize().height
636 );
637 componentIndex = componentIndex + 4;
638 break;
639 case FormatLayout.LCBLC:
640 c0 = parent.getComponent(componentIndex);
641 c0.setBounds(
642 rowX[0],
643 rowY + (this.rowHeights[rowIndex]
644 - c0.getPreferredSize().height) / 2,
645 this.columnWidths[0], c0.getPreferredSize().height
646 );
647 c1 = parent.getComponent(componentIndex + 1);
648 c1.setBounds(
649 rowX[1],
650 rowY + (this.rowHeights[rowIndex]
651 - c1.getPreferredSize().height) / 2,
652 this.columnWidths[1], c1.getPreferredSize().height
653 );
654 c2 = parent.getComponent(componentIndex + 2);
655 c2.setBounds(
656 rowX[2],
657 rowY + (this.rowHeights[rowIndex]
658 - c2.getPreferredSize().height) / 2,
659 this.columnWidths[2], c2.getPreferredSize().height
660 );
661 c3 = parent.getComponent(componentIndex + 3);
662 c3.setBounds(
663 rowX[3],
664 rowY + (this.rowHeights[rowIndex]
665 - c3.getPreferredSize().height) / 2,
666 this.columnWidths[3], c3.getPreferredSize().height
667 );
668 c4 = parent.getComponent(componentIndex + 4);
669 c4.setBounds(
670 rowX[4],
671 rowY + (this.rowHeights[rowIndex]
672 - c4.getPreferredSize().height) / 2,
673 w4to5, c4.getPreferredSize().height
674 );
675 componentIndex = componentIndex + 5;
676 break;
677 case FormatLayout.LCLCB:
678 c0 = parent.getComponent(componentIndex);
679 c0.setBounds(
680 rowX[0],
681 rowY + (this.rowHeights[rowIndex]
682 - c0.getPreferredSize().height) / 2,
683 this.columnWidths[0], c0.getPreferredSize().height
684 );
685 c1 = parent.getComponent(componentIndex + 1);
686 c1.setBounds(
687 rowX[1],
688 rowY + (this.rowHeights[rowIndex]
689 - c1.getPreferredSize().height) / 2,
690 w1to2, c1.getPreferredSize().height
691 );
692 c2 = parent.getComponent(componentIndex + 2);
693 c2.setBounds(
694 rowX[3],
695 rowY + (this.rowHeights[rowIndex]
696 - c2.getPreferredSize().height) / 2,
697 this.columnWidths[3], c2.getPreferredSize().height
698 );
699 c3 = parent.getComponent(componentIndex + 3);
700 c3.setBounds(
701 rowX[4],
702 rowY + (this.rowHeights[rowIndex]
703 - c3.getPreferredSize().height) / 2,
704 this.columnWidths[4], c3.getPreferredSize().height
705 );
706 c4 = parent.getComponent(componentIndex + 4);
707 c4.setBounds(
708 rowX[5],
709 rowY + (this.rowHeights[rowIndex]
710 - c4.getPreferredSize().height) / 2,
711 this.columnWidths[5], c4.getPreferredSize().height
712 );
713 componentIndex = componentIndex + 5;
714 break;
715 case FormatLayout.LCBLCB:
716 c0 = parent.getComponent(componentIndex);
717 c0.setBounds(
718 rowX[0],
719 rowY + (this.rowHeights[rowIndex]
720 - c0.getPreferredSize().height) / 2,
721 this.columnWidths[0], c0.getPreferredSize().height
722 );
723 c1 = parent.getComponent(componentIndex + 1);
724 c1.setBounds(
725 rowX[1],
726 rowY + (this.rowHeights[rowIndex]
727 - c1.getPreferredSize().height) / 2,
728 this.columnWidths[1], c1.getPreferredSize().height
729 );
730 c2 = parent.getComponent(componentIndex + 2);
731 c2.setBounds(
732 rowX[2],
733 rowY + (this.rowHeights[rowIndex]
734 - c2.getPreferredSize().height) / 2,
735 this.columnWidths[2], c2.getPreferredSize().height
736 );
737 c3 = parent.getComponent(componentIndex + 3);
738 c3.setBounds(
739 rowX[3],
740 rowY + (this.rowHeights[rowIndex]
741 - c3.getPreferredSize().height) / 2,
742 this.columnWidths[3], c3.getPreferredSize().height
743 );
744 c4 = parent.getComponent(componentIndex + 4);
745 c4.setBounds(
746 rowX[4],
747 rowY + (this.rowHeights[rowIndex]
748 - c4.getPreferredSize().height) / 2,
749 this.columnWidths[4], c4.getPreferredSize().height
750 );
751 c5 = parent.getComponent(componentIndex + 5);
752 c5.setBounds(
753 rowX[5],
754 rowY + (this.rowHeights[rowIndex]
755 - c5.getPreferredSize().height) / 2,
756 this.columnWidths[5], c5.getPreferredSize().height
757 );
758 componentIndex = componentIndex + 6;
759 break;
760 }
761 rowY = rowY + this.rowHeights[rowIndex] + this.rowGap;
762 }
763 }
764 }
765
766 /**
767 * Processes a row in 'C' format.
768 *
769 * @param rowIndex the row index.
770 * @param d0 dimension 0.
771 */
772 protected void updateC(final int rowIndex, final Dimension d0) {
773 this.rowHeights[rowIndex] = d0.height;
774 this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
775 this.columns0to5Width = Math.max(this.columns0to5Width, d0.width);
776 }
777
778 /**
779 * Processes a row in 'LC' format.
780 *
781 * @param rowIndex the row index.
782 * @param d0 dimension 0.
783 * @param d1 dimension 1.
784 */
785 protected void updateLC(final int rowIndex, final Dimension d0,
786 final Dimension d1) {
787
788 this.rowHeights[rowIndex] = Math.max(d0.height, d1.height);
789 this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
790 this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
791 this.columns1to5Width = Math.max(this.columns1to5Width, d1.width);
792
793 }
794
795 /**
796 * Processes a row in 'LCB' format.
797 *
798 * @param rowIndex the row index.
799 * @param d0 dimension 0.
800 * @param d1 dimension 1.
801 * @param d2 dimension 2.
802 */
803 protected void updateLCB(final int rowIndex,
804 final Dimension d0, final Dimension d1,
805 final Dimension d2) {
806
807 this.rowHeights[rowIndex]
808 = Math.max(d0.height, Math.max(d1.height, d2.height));
809 this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
810 this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
811 this.columns1to4Width = Math.max(this.columns1to4Width, d1.width);
812 this.columnWidths[5] = Math.max(this.columnWidths[5], d2.width);
813
814 }
815
816 /**
817 * Processes a row in 'LCLC' format.
818 *
819 * @param rowIndex the row index.
820 * @param d0 dimension 0.
821 * @param d1 dimension 1.
822 * @param d2 dimension 2.
823 * @param d3 dimension 3.
824 */
825 protected void updateLCLC(final int rowIndex, final Dimension d0,
826 final Dimension d1, final Dimension d2,
827 final Dimension d3) {
828
829 this.rowHeights[rowIndex] = Math.max(Math.max(d0.height, d1.height),
830 Math.max(d2.height, d3.height));
831 this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
832 this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
833 this.columns1and2Width = Math.max(this.columns1and2Width, d1.width);
834 this.columnWidths[3] = Math.max(this.columnWidths[3], d2.width);
835 this.columns4and5Width = Math.max(this.columns4and5Width, d3.width);
836 }
837
838 /**
839 * Processes a row in 'LCBLC' format.
840 *
841 * @param rowIndex the row index.
842 * @param d0 dimension 0.
843 * @param d1 dimension 1.
844 * @param d2 dimension 2.
845 * @param d3 dimension 3.
846 * @param d4 dimension 4.
847 */
848 protected void updateLCBLC(final int rowIndex, final Dimension d0,
849 final Dimension d1, final Dimension d2,
850 final Dimension d3, final Dimension d4) {
851
852 this.rowHeights[rowIndex] = (Math.max(
853 d0.height,
854 Math.max(Math.max(d1.height, d2.height),
855 Math.max(d3.height, d4.height)))
856 );
857 this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
858 this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
859 this.columnWidths[1] = Math.max(this.columnWidths[1], d1.width);
860 this.columnWidths[2] = Math.max(this.columnWidths[2], d2.width);
861 this.columnWidths[3] = Math.max(this.columnWidths[3], d3.width);
862 this.columns4and5Width = Math.max(this.columns4and5Width, d4.width);
863
864 }
865
866 /**
867 * Processes a row in 'LCLCB' format.
868 *
869 * @param rowIndex the row index.
870 * @param d0 dimension 0.
871 * @param d1 dimension 1.
872 * @param d2 dimension 2.
873 * @param d3 dimension 3.
874 * @param d4 dimension 4.
875 */
876 protected void updateLCLCB(final int rowIndex, final Dimension d0,
877 final Dimension d1, final Dimension d2,
878 final Dimension d3, final Dimension d4) {
879
880 this.rowHeights[rowIndex] = (Math.max(d0.height,
881 Math.max(Math.max(d1.height, d2.height),
882 Math.max(d3.height, d4.height))));
883 this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
884 this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
885 this.columns1and2Width = Math.max(this.columns1and2Width, d1.width);
886 this.columnWidths[3] = Math.max(this.columnWidths[3], d2.width);
887 this.columnWidths[4] = Math.max(this.columnWidths[4], d3.width);
888 this.columnWidths[5] = Math.max(this.columnWidths[5], d4.width);
889
890 }
891
892 /**
893 * Processes a row in 'LCBLCB' format.
894 *
895 * @param rowIndex the row index.
896 * @param d0 dimension 0.
897 * @param d1 dimension 1.
898 * @param d2 dimension 2.
899 * @param d3 dimension 3.
900 * @param d4 dimension 4.
901 * @param d5 dimension 5.
902 */
903 protected void updateLCBLCB(final int rowIndex,
904 final Dimension d0, final Dimension d1,
905 final Dimension d2,
906 final Dimension d3, final Dimension d4,
907 final Dimension d5) {
908
909 this.rowHeights[rowIndex] = Math.max(
910 Math.max(d0.height, d1.height),
911 Math.max(Math.max(d2.height, d3.height),
912 Math.max(d4.height, d5.height))
913 );
914 this.totalHeight = this.totalHeight + this.rowHeights[rowIndex];
915 this.columnWidths[0] = Math.max(this.columnWidths[0], d0.width);
916 this.columnWidths[1] = Math.max(this.columnWidths[1], d1.width);
917 this.columnWidths[2] = Math.max(this.columnWidths[2], d2.width);
918 this.columnWidths[3] = Math.max(this.columnWidths[3], d3.width);
919 this.columnWidths[4] = Math.max(this.columnWidths[4], d4.width);
920 this.columnWidths[5] = Math.max(this.columnWidths[5], d5.width);
921
922 }
923
924 /**
925 * Finishes of the processing.
926 */
927 public void complete() {
928
929 this.columnWidths[1] = Math.max(
930 this.columnWidths[1],
931 this.columns1and2Width - this.columnGaps[1] - this.columnWidths[2]
932 );
933
934 this.columnWidths[4] = Math.max(
935 this.columnWidths[4],
936 Math.max(
937 this.columns4and5Width - this.columnGaps[4]
938 - this.columnWidths[5],
939 Math.max(
940 this.columns1to4Width - this.columnGaps[1]
941 - this.columnGaps[2] - this.columnGaps[3]
942 - this.columnWidths[1] - this.columnWidths[2]
943 - this.columnWidths[3],
944 this.columns1to5Width - this.columnGaps[1]
945 - this.columnGaps[2] - this.columnGaps[3]
946 - this.columnWidths[1] - this.columnWidths[2]
947 - this.columnWidths[3] - this.columnGaps[4]
948 )
949 )
950 );
951
952 int leftWidth = this.columnWidths[0] + this.columnGaps[0]
953 + this.columnWidths[1] + this.columnGaps[1]
954 + this.columnWidths[2];
955
956 int rightWidth = this.columnWidths[3] + this.columnGaps[3]
957 + this.columnWidths[4] + this.columnGaps[4]
958 + this.columnWidths[5];
959
960 if (splitLayout()) {
961 if (leftWidth > rightWidth) {
962 final int mismatch = leftWidth - rightWidth;
963 this.columnWidths[4] = this.columnWidths[4] + mismatch;
964 rightWidth = rightWidth + mismatch;
965 }
966 else {
967 final int mismatch = rightWidth - leftWidth;
968 this.columnWidths[1] = this.columnWidths[1] + mismatch;
969 leftWidth = leftWidth + mismatch;
970 }
971 }
972
973 this.totalWidth = leftWidth + this.columnGaps[2] + rightWidth;
974
975 if (this.columns0to5Width > this.totalWidth) {
976 final int spaceToAdd = (this.columns0to5Width - this.totalWidth);
977 if (splitLayout()) {
978 final int halfSpaceToAdd = spaceToAdd / 2;
979 this.columnWidths[1] = this.columnWidths[1] + halfSpaceToAdd;
980 this.columnWidths[4] = this.columnWidths[4] + spaceToAdd
981 - halfSpaceToAdd;
982 this.totalWidth = this.totalWidth + spaceToAdd;
983 }
984 else {
985 this.columnWidths[1] = this.columnWidths[1] + spaceToAdd;
986 this.totalWidth = this.totalWidth + spaceToAdd;
987 }
988 }
989
990 }
991
992 /**
993 * Returns true if this layout involves a split into two sections.
994 *
995 * @return <code>true</code> if this layout involves a split into two
996 * sections.
997 */
998 private boolean splitLayout() {
999 for (int i = 0; i < this.rowFormats.length; i++) {
1000 if (this.rowFormats[i] > FormatLayout.LCB) {
1001 return true;
1002 }
1003 }
1004 return false;
1005 }
1006
1007 /**
1008 * Not used.
1009 *
1010 * @param comp the component.
1011 */
1012 public void addLayoutComponent(final Component comp) {
1013 // not used
1014 }
1015
1016 /**
1017 * Not used.
1018 *
1019 * @param comp the component.
1020 */
1021 public void removeLayoutComponent(final Component comp) {
1022 // not used
1023 }
1024
1025 /**
1026 * Not used.
1027 *
1028 * @param name the component name.
1029 * @param comp the component.
1030 */
1031 public void addLayoutComponent(final String name, final Component comp) {
1032 // not used
1033 }
1034
1035 /**
1036 * Not used.
1037 *
1038 * @param name the component name.
1039 * @param comp the component.
1040 */
1041 public void removeLayoutComponent(final String name, final Component comp) {
1042 // not used
1043 }
1044
1045 }