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 045package org.jfree.layout; 046 047import java.awt.Component; 048import java.awt.Container; 049import java.awt.Dimension; 050import java.awt.Insets; 051import java.awt.LayoutManager; 052import 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 */ 060public 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}